Example usage for javax.lang.model.util ElementFilter constructorsIn

Introduction

In this page you can find the example usage for javax.lang.model.util ElementFilter constructorsIn.

Prototype

public static Set<ExecutableElement> constructorsIn(Set<? extends Element> elements) 

Source Link

Document

Returns a set of constructors in elements .

Usage

From source file:info.archinnov.achilles.internals.parser.validator.BeanValidator.java

public static void validateHasPublicConstructor(AptUtils aptUtils, TypeName typeName, TypeElement typeElement) {
    final long constructorCount = ElementFilter.constructorsIn(typeElement.getEnclosedElements()).stream()
            .filter(x -> x.getModifiers().contains(Modifier.PUBLIC)) // public constructor
            .filter(x -> x.getParameters().size() == 0) //No arg constructor
            .count();/*from  w w  w  .  j av  a  2 s  .c  o  m*/
    aptUtils.validateTrue(constructorCount == 1, "Bean type '%s' should have a public constructor", typeName);
}

---

From source file:com.github.pellaton.jazoon2012.JazoonProcessor.java

private void processElement(TypeElement typeElement) {
    for (AnnotationMirror annotation : typeElement.getAnnotationMirrors()) {
        Element annotationTypeElement = annotation.getAnnotationType().asElement();
        if (annotationTypeElement.equals(this.configurationTypeElement)) {
            List<? extends Element> enclosedElements = typeElement.getEnclosedElements();

            processClass(typeElement, ElementFilter.constructorsIn(enclosedElements));

            for (ExecutableElement method : ElementFilter.methodsIn(enclosedElements)) {
                processMethod(typeElement, method);
            }//from  w  w w .  j a v a2  s .c  om
        }
    }

}

---

From source file:com.github.pellaton.springconfigvalidation.SpringConfigurationValidationProcessor.java

private void processElement(Element element) {
    for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
        Element annotationTypeElement = annotation.getAnnotationType().asElement();

        if (annotationTypeElement.equals(this.configurationTypeElement)) {
            List<? extends Element> enclosedElements = element.getEnclosedElements();
            processClass(element, ElementFilter.constructorsIn(enclosedElements));

        } else if (annotationTypeElement.equals(this.beanTypeElement)) {
            processBeanMethod((ExecutableElement) element);
        }//w  w  w  .ja v  a2  s .  c  o  m
    }
}

---

From source file:co.touchlab.squeaky.processor.AnnotationProcessor.java

private boolean processTableViewQuery(List<DatabaseTableHolder> tableHolders, Element annotatedElement,
        EntityType entityType) {/*from   ww w.j  a  v a 2 s  .c o  m*/
    TypeElement typeElement = (TypeElement) annotatedElement;
    String fromString;

    switch (entityType) {
    case Table:
    case View:
        fromString = extractTableName(typeElement);
        break;
    case Query:
        fromString = "(" + typeElement.getAnnotation(DatabaseQuery.class).fromQuery() + ")";
        break;
    default:
        throw new RuntimeException("No type (this will NEVER happen)");
    }

    List<FieldTypeGen> fieldTypeGens = new ArrayList<FieldTypeGen>();
    List<ForeignCollectionHolder> foreignCollectionInfos = new ArrayList<ForeignCollectionHolder>();

    // walk up the classes finding the fields
    TypeElement working = typeElement;
    while (working != null) {
        for (Element element : working.getEnclosedElements()) {

            if (element.getKind().isField()) {
                if (element.getAnnotation(DatabaseField.class) != null) {
                    FieldTypeGen fieldTypeGen = new FieldTypeGen(annotatedElement, element, typeUtils,
                            messager);

                    fieldTypeGens.add(fieldTypeGen);

                } else if (element.getAnnotation(ForeignCollectionField.class) != null) {
                    ForeignCollectionField foreignCollectionField = element
                            .getAnnotation(ForeignCollectionField.class);
                    foreignCollectionInfos.add(new ForeignCollectionHolder(foreignCollectionField,
                            (VariableElement) element, messager));
                }
            }
        }
        if (working.getSuperclass().getKind().equals(TypeKind.NONE)) {
            break;
        }
        working = (TypeElement) typeUtils.asElement(working.getSuperclass());
    }
    if (fieldTypeGens.isEmpty()) {
        error(typeElement,
                "Every class annnotated with %s, %s, or %s must have at least 1 field annotated with %s",
                DatabaseTable.class.getSimpleName(), DatabaseView.class.getSimpleName(),
                DatabaseQuery.class.getSimpleName(), DatabaseField.class.getSimpleName());
        return true;
    }

    List<FieldTypeGen> testFields = fieldTypeGens;
    List<FieldTypeGen> finalFields = new ArrayList<FieldTypeGen>();
    for (FieldTypeGen testField : testFields) {
        if (testField.finalField)
            finalFields.add(testField);
    }

    ExecutableElement finalConstructor = null;

    if (!finalFields.isEmpty()) {
        List<ExecutableElement> executableElements = ElementFilter
                .constructorsIn(annotatedElement.getEnclosedElements());
        for (ExecutableElement executableElement : executableElements) {
            List<FieldTypeGen> finalFieldsCheck = new ArrayList<FieldTypeGen>(finalFields);
            List<? extends VariableElement> parameters = executableElement.getParameters();
            for (VariableElement parameter : parameters) {
                String fieldName = parameter.getSimpleName().toString();
                String fieldClassname = DataTypeManager.findFieldClassname(parameter);

                Iterator<FieldTypeGen> iterator = finalFieldsCheck.iterator();
                boolean found = false;
                while (iterator.hasNext()) {
                    FieldTypeGen next = iterator.next();
                    if (next.fieldName.equals(fieldName) && next.dataTypeClassname.equals(fieldClassname)) {
                        found = true;
                        iterator.remove();
                    }
                }
                if (!found)
                    break;
            }

            if (finalFieldsCheck.isEmpty()) {
                finalConstructor = executableElement;
                break;
            }
        }

        if (finalConstructor == null) {
            List<String> allFinals = new ArrayList<String>();
            for (FieldTypeGen finalField : finalFields) {
                allFinals.add(finalField.fieldName);
            }
            error(annotatedElement, "Final fields need to be set in constructor %s",
                    StringUtils.join(allFinals, ","));
            return true;
        }
    }

    DatabaseTableHolder tableHolder = new DatabaseTableHolder(annotatedElement, fieldTypeGens,
            foreignCollectionInfos, typeElement, fromString, finalFields, finalConstructor, entityType);

    tableHolders.add(tableHolder);
    return false;
}

---

From source file:io.github.jeddict.jcode.util.JavaSourceHelper.java

public static MethodTree getDefaultConstructor(CompilationController controller) {
    TypeElement classElement = getTopLevelClassElement(controller);
    if (classElement == null) {
        return null;
    }/*from ww  w .  j ava 2 s.  c om*/
    List<ExecutableElement> constructors = ElementFilter.constructorsIn(classElement.getEnclosedElements());

    for (ExecutableElement constructor : constructors) {
        if (constructor.getParameters().isEmpty()) {
            return controller.getTrees().getTree(constructor);
        }
    }

    return null;
}

---

From source file:org.androidannotations.helper.ValidatorHelper.java

public void extendsOrmLiteDao(Element element, IsValid valid, OrmLiteHelper ormLiteHelper) {
    if (!valid.isValid()) {
        // we now that the element is invalid. early exit as the reason
        // could be missing ormlite classes
        return;/*w  ww. j av a 2  s.  co  m*/
    }

    TypeMirror elementTypeMirror = element.asType();
    Types typeUtils = annotationHelper.getTypeUtils();

    DeclaredType daoParametrizedType = ormLiteHelper.getDaoParametrizedType();
    DeclaredType runtimeExceptionDaoParametrizedType = ormLiteHelper.getRuntimeExceptionDaoParametrizedType();

    // Checks that elementType extends Dao<?, ?> or
    // RuntimeExceptionDao<?, ?>
    if (!annotationHelper.isSubtype(elementTypeMirror, daoParametrizedType)
            && !annotationHelper.isSubtype(elementTypeMirror, runtimeExceptionDaoParametrizedType)) {
        valid.invalidate();
        annotationHelper.printAnnotationError(element,
                "%s can only be used on an element that extends " + daoParametrizedType.toString() //
                        + " or " + runtimeExceptionDaoParametrizedType.toString());
        return;
    }

    if (annotationHelper.isSubtype(elementTypeMirror, runtimeExceptionDaoParametrizedType) //
            && !typeUtils.isAssignable(ormLiteHelper.getTypedRuntimeExceptionDao(element), elementTypeMirror)) {

        boolean hasConstructor = false;
        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) {
                TypeMirror type = parameters.get(0).asType();
                if (annotationHelper.isSubtype(type, daoWithTypedParameters)) {
                    hasConstructor = true;
                }
            }
        }
        if (!hasConstructor) {
            valid.invalidate();
            annotationHelper.printAnnotationError(element, elementTypeMirror.toString()
                    + " requires a constructor that takes only a " + daoWithTypedParameters.toString());
        }
    }
}

---

From source file:io.github.jeddict.jcode.util.JavaSourceHelper.java

public static ExecutableElement getLongestContructor(TypeElement typeElement) {
    List<ExecutableElement> constructors = ElementFilter.constructorsIn(typeElement.getEnclosedElements());
    int max = -1;
    ExecutableElement current = null;
    for (ExecutableElement constructor : constructors) {
        if (constructor.getParameters().size() > max) {
            max = constructor.getParameters().size();
            current = constructor;/* w w w .  j  a  v  a 2 s. c  o  m*/
        }
    }
    return current;
}

---

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void hasEmptyOrContextConstructor(Element element, IsValid valid) {
    List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements());

    if (constructors.size() == 1) {
        ExecutableElement constructor = constructors.get(0);

        if (!annotationHelper.isPrivate(constructor)) {
            if (constructor.getParameters().size() > 1) {
                annotationHelper.printAnnotationError(element,
                        "%s annotated element should have a constructor with one parameter max, of type "
                                + CanonicalNameConstants.CONTEXT);
                valid.invalidate();//from   ww  w . j ava2 s  .c o m
            } else if (constructor.getParameters().size() == 1) {
                VariableElement parameter = constructor.getParameters().get(0);
                if (!parameter.asType().toString().equals(CanonicalNameConstants.CONTEXT)) {
                    annotationHelper.printAnnotationError(element,
                            "%s annotated element should have a constructor with one parameter max, of type "
                                    + CanonicalNameConstants.CONTEXT);
                    valid.invalidate();
                }
            }
        } else {
            annotationHelper.printAnnotationError(element,
                    "%s annotated element should not have a private constructor");
            valid.invalidate();
        }
    } else {
        annotationHelper.printAnnotationError(element, "%s annotated element should have only one constructor");
        valid.invalidate();
    }
}

---

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void hasEmptyConstructor(Element element, IsValid valid) {

    List<ExecutableElement> constructors = ElementFilter.constructorsIn(element.getEnclosedElements());

    if (constructors.size() == 1) {

        ExecutableElement constructor = constructors.get(0);

        if (!annotationHelper.isPrivate(constructor)) {
            if (constructor.getParameters().size() != 0) {
                annotationHelper.printAnnotationError(element,
                        "%s annotated element should have an empty constructor");
                valid.invalidate();/*  ww  w.j  a  va2 s  .c  om*/
            }
        } else {
            annotationHelper.printAnnotationError(element,
                    "%s annotated element should not have a private constructor");
            valid.invalidate();
        }
    } else {
        annotationHelper.printAnnotationError(element, "%s annotated element should have only one constructor");
        valid.invalidate();
    }
}

---

From source file:org.androidannotations.helper.ValidatorHelper.java

public void isAbstractOrHasEmptyOrContextConstructor(Element element, IsValid 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) {
                    annotationHelper.printAnnotationError(element,
                            "%s annotated element should have a constructor with one parameter max, of type "
                                    + CanonicalNameConstants.CONTEXT);
                    valid.invalidate();// w  w  w. j a va2s  .  com
                } else if (constructor.getParameters().size() == 1) {
                    VariableElement parameter = constructor.getParameters().get(0);
                    if (!parameter.asType().toString().equals(CanonicalNameConstants.CONTEXT)) {
                        annotationHelper.printAnnotationError(element,
                                "%s annotated element should have a constructor with one parameter max, of type "
                                        + CanonicalNameConstants.CONTEXT);
                        valid.invalidate();
                    }
                }
            } else {
                annotationHelper.printAnnotationError(element,
                        "%s annotated element should not have a private constructor");
                valid.invalidate();
            }
        } else {
            annotationHelper.printAnnotationError(element,
                    "%s annotated element should have only one constructor");
            valid.invalidate();
        }
    }
}

---

• «
• 1
• 2
• »