Java Code Examples for javax.lang.model.element.AnnotationMirror#getAnnotationType()

static void findQualifiers(Element element , 
        AnnotationModelHelper helper , boolean event , 
        AnnotationHandleStrategy strategy )
{
    List<? extends AnnotationMirror> allAnnotationMirrors = 
        helper.getCompilationController().getElements().
        getAllAnnotationMirrors( element );
    for (AnnotationMirror annotationMirror : allAnnotationMirrors) {
        DeclaredType annotationType = annotationMirror
                .getAnnotationType();
        if ( annotationType == null || annotationType.getKind() == TypeKind.ERROR){
            continue;
        }
        TypeElement annotationElement = (TypeElement) annotationType
                .asElement();
        if (annotationElement!= null && isQualifier(annotationElement, 
                helper , event )) 
        {
            strategy.handleAnnotation(annotationMirror , annotationElement );
        }
    }
}
 

/**
 * Returns the completion candidates from the annotations present on the specified element.
 * @param element the method or field annotated with {@code @Option} or {@code @Parameters}
 * @return the completion candidates or {@code null} if not found
 */
public static Iterable<String> extract(Element element) {
    List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
    for (AnnotationMirror mirror : annotationMirrors) {
        DeclaredType annotationType = mirror.getAnnotationType();
        if (TypeUtil.isOption(annotationType) || TypeUtil.isParameter(annotationType)) {
            Map<? extends ExecutableElement, ? extends AnnotationValue> elementValues = mirror.getElementValues();
            for (ExecutableElement attribute : elementValues.keySet()) {
                if ("completionCandidates".equals(attribute.getSimpleName().toString())) {
                    AnnotationValue typeMirror = elementValues.get(attribute);
                    return new CompletionCandidatesMetaData((TypeMirror) typeMirror);
                }
            }
        }
    }
    return null;
}
 

/**
 * Returns the type converters from the annotations present on the specified element.
 * @param element the method or field annotated with {@code @Option} or {@code @Parameters}
 * @return the type converters or an empty array if not found
 */
@SuppressWarnings("unchecked")
public static TypeConverterMetaData[] extract(Element element) {
    List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
    for (AnnotationMirror mirror : annotationMirrors) {
        DeclaredType annotationType = mirror.getAnnotationType();
        if (TypeUtil.isOption(annotationType) || TypeUtil.isParameter(annotationType)) {
            Map<? extends ExecutableElement, ? extends AnnotationValue> elementValues = mirror.getElementValues();
            for (ExecutableElement attribute : elementValues.keySet()) {
                if ("converter".equals(attribute.getSimpleName().toString())) {
                    AnnotationValue list = elementValues.get(attribute);
                    List<AnnotationValue> typeMirrors = (List<AnnotationValue>) list.getValue();
                    List<TypeConverterMetaData> result = new ArrayList<TypeConverterMetaData>();
                    for (AnnotationValue annotationValue : typeMirrors) {
                        result.add(new TypeConverterMetaData((TypeMirror) annotationValue.getValue()));
                    }
                    return result.toArray(new TypeConverterMetaData[0]);
                }
            }
        }
    }
    return new TypeConverterMetaData[0];
}
 

@Override
public Set<FieldData> getDependFields(TypeElement te) {
    Set<FieldData> list = new HashSet<>();

    List<? extends AnnotationMirror> mirrors = te.getAnnotationMirrors();
    AnnotationMirror expect = null;
    for(AnnotationMirror am : mirrors){
        DeclaredType type = am.getAnnotationType();
        if(type.toString().equals(Fields.class.getName())){
            expect = am;
            break;
        }
    }
    if(expect != null){
        ElementHelper.parseFields(elements, types, expect, list, pp);
    }
    //a depend b, b depend c ,,, etc.
    List<? extends TypeMirror> superInterfaces = te.getInterfaces();
    for(TypeMirror tm : superInterfaces){
        final TypeElement newTe = (TypeElement) ((DeclaredType) tm).asElement();
        list.addAll(getDependFields(newTe)); //recursion
    }
    return list;
}
 

private Triple<VariableElement, Integer, Void> doGetObserverParameter( 
        ExecutableElement element )
{
    List<? extends VariableElement> parameters = element.getParameters();
    int index = 0 ; 
    for (VariableElement parameter : parameters) {
        List<? extends AnnotationMirror> allAnnotationMirrors = 
            getCompilationController().getElements().
            getAllAnnotationMirrors( parameter );
        for (AnnotationMirror annotationMirror : allAnnotationMirrors) {
            DeclaredType annotationType = annotationMirror.getAnnotationType();
            TypeElement annotation = (TypeElement)annotationType.asElement();
            if ( annotation == null ){
                continue;
            }
            if ( OBSERVES_ANNOTATION.contentEquals( annotation.getQualifiedName())){
                return new Triple<VariableElement, Integer, Void>(parameter, index, null);
            }
        }
        index++;
    }
    return null;
}
 

private static void checkDatasourceField(TypeElement typeElement, String name) {
    List<VariableElement> elements = ElementFilter.fieldsIn(typeElement.getEnclosedElements());
    VariableElement variableElement = elements.get(0);
    assertTrue(variableElement.getSimpleName().contentEquals(name)); // field name
    DeclaredType declaredType = (DeclaredType) variableElement.asType();
    TypeElement returnTypeElement = (TypeElement) declaredType.asElement();
    assertTrue(returnTypeElement.getQualifiedName().contentEquals("javax.sql.DataSource")); // field type
    AnnotationMirror annotationMirror = variableElement.getAnnotationMirrors().get(0);
    DeclaredType annotationDeclaredType = annotationMirror.getAnnotationType();
    TypeElement annotationTypeElement = (TypeElement) annotationDeclaredType.asElement();
    assertTrue(annotationTypeElement.getQualifiedName().contentEquals("javax.annotation.Resource")); // annotation type
    Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry = annotationMirror.getElementValues().entrySet().iterator().next();
    String attributeName = entry.getKey().getSimpleName().toString();
    String attributeValue = (String) entry.getValue().getValue();
    assertEquals("name", attributeName); // attributes
    assertEquals(name, attributeValue);
}
 

protected void appendAnnotationMirror( AnnotationMirror mirror , StringBuilder builder , 
        boolean isFqn )
{
    DeclaredType type = mirror.getAnnotationType();
    Element annotation = type.asElement();
    
    builder.append('@');
    String annotationName ;
    if ( isFqn ) {
        annotationName= ( annotation instanceof TypeElement )?
            ((TypeElement)annotation).getQualifiedName().toString() : 
                annotation.getSimpleName().toString();
    }
    else { 
        annotationName = annotation.getSimpleName().toString();
    }
    
    builder.append( annotationName );
    
    appendBindingParamters( mirror , builder );
    
    builder.append(", ");           // NOI18N
}
 

@Override
public String getName( Element element)
{
    String name = inspectSpecializes( element );
    if ( name != null ){
        return name;
    }
    List<AnnotationMirror> allStereotypes = getAllStereotypes(element, 
            getModel().getHelper().getHelper());
    for (AnnotationMirror annotationMirror : allStereotypes) {
        DeclaredType annotationType = annotationMirror.getAnnotationType();
        TypeElement annotation = (TypeElement)annotationType.asElement();
        if ( AnnotationObjectProvider.hasAnnotation(annotation, 
                NAMED_QUALIFIER_ANNOTATION, getModel().getHelper() ) )
        {
            return getNamedName(element , null);
        }
    }
    return null;
}
 

static boolean hasAnnotation(Element element,String fqn){
    List<? extends AnnotationMirror> annotationMirrors = 
        element.getAnnotationMirrors();
    for (AnnotationMirror annotationMirror : annotationMirrors) {
        DeclaredType annotationType = annotationMirror.getAnnotationType();
        Element annotationElement = annotationType.asElement();
        if ( annotationElement instanceof TypeElement ){
            Name qualifiedName = ((TypeElement)annotationElement).
                getQualifiedName();
            if ( qualifiedName.contentEquals(fqn)){
                return true;
            }
        }
    }
    return false;
}
 

public static AnnotationMirror findAnnotationMirror(ProcessingEnvironment processingEnv, List<? extends AnnotationMirror> mirrors, Class<?> annotationClass) {
    TypeElement expectedAnnotationType = processingEnv.getElementUtils().getTypeElement(annotationClass.getCanonicalName());
    for (AnnotationMirror mirror : mirrors) {
        DeclaredType annotationType = mirror.getAnnotationType();
        TypeElement actualAnnotationType = (TypeElement) annotationType.asElement();
        if (actualAnnotationType.equals(expectedAnnotationType)) {
            return mirror;
        }
    }
    return null;
}
 

private void handleAnnotation(final AnnotationHandler handler, 
        final TypeElement typeElement, final Element element, 
        final String searchedTypeName, Set<ElementKind> kinds, 
        boolean includeDerived) throws InterruptedException 
{
    
    List<? extends AnnotationMirror> fieldAnnotationMirrors = element.getAnnotationMirrors();
    for (AnnotationMirror annotationMirror : fieldAnnotationMirrors) {
        DeclaredType annotationType = annotationMirror.getAnnotationType();
        String annotationTypeName = getHelper().getAnnotationTypeName(annotationType);
        // issue 110819: need to compare the real type names, since the annotation can be @<any>
        if (searchedTypeName.equals(annotationTypeName)) {
            LOGGER.log(
                    Level.FINE,
                    "notifying type {0}, element {1}, annotation {2}", // NOI18N
                    new Object[] { typeElement.getQualifiedName(), 
                            element.getSimpleName(), annotationMirror });
            // this check was originally missed for Types........
            if ( kinds.contains( element.getKind())){
                handler.handleAnnotation(typeElement, element, annotationMirror);
            }
            if ( includeDerived && element.getKind() == ElementKind.CLASS ){
                discoverHierarchy( typeElement , annotationMirror , 
                        handler, kinds);
            }
        } else {
            LOGGER.log(
                    Level.FINE,
                    "type name mismatch, ignoring type {0}, element {1}, annotation {2}", // NOI18N
                    new Object[] { typeElement.getQualifiedName(), element.getSimpleName(), annotationMirror });
        }
    }
}
 

public static Collection<String> extractAnnotationNames(Element elem) {
    Collection<String> annotationsOnElement = new LinkedList<String>();

    for (AnnotationMirror ann : elem.getAnnotationMirrors()) {
        TypeMirror annType = ann.getAnnotationType();
        Element typeElem = ((DeclaredType) annType).asElement();
        String typeName = ((TypeElement) typeElem).getQualifiedName().toString();
        annotationsOnElement.add(typeName);
    }

    return annotationsOnElement;
}
 

private Collection<Method> doBuildResource( final Resource resource,
        TypeElement clazz, CompilationController controller , 
        Collection<TypeMirror> boxedPrimitives )
{
    String fqn = clazz.getQualifiedName().toString();
    if ( resourceFqns.contains( fqn)){
        return Collections.emptyList();
    }
    else {
        resourceFqns.add( fqn);
    }
    Collection<Method> result = new LinkedList<Method>();

    List<ExecutableElement> methods = ElementFilter.methodsIn(controller
            .getElements().getAllMembers(clazz));

    for (ExecutableElement method : methods) {
        List<? extends AnnotationMirror> annotationMirrors = controller
                .getElements().getAllAnnotationMirrors(method);
        Map<String, AnnotationMirror> restAnnotations = new HashMap<String, 
            AnnotationMirror>();
        for (AnnotationMirror annotationMirror : annotationMirrors) {
            DeclaredType annotationType = annotationMirror
                    .getAnnotationType();
            Element annotationElement = annotationType.asElement();
            if (annotationElement instanceof TypeElement) {
                TypeElement annotation = (TypeElement) annotationElement;
                String fqnAnnotation = annotation.getQualifiedName()
                        .toString();
                if (isRestAnnotation(fqnAnnotation)) {
                    restAnnotations.put(fqnAnnotation, annotationMirror);
                }
            }
        }
        Collection<Method> collection = createRestMethods(resource,
                restAnnotations, clazz, method, controller, boxedPrimitives);
        result.addAll(collection);
    }
    return result;
}
 

private String doGetName( Element original , Element element ){
    List<? extends AnnotationMirror> annotations = getModel().getHelper().
        getCompilationController().getElements().getAllAnnotationMirrors( 
            element);
    for (AnnotationMirror annotationMirror : annotations) {
    DeclaredType type = annotationMirror.getAnnotationType();
    TypeElement annotationElement = (TypeElement)type.asElement();
        if ( NAMED_QUALIFIER_ANNOTATION.contentEquals( 
                annotationElement.getQualifiedName()))
        {
            return getNamedName( original , annotationMirror );
        }
    }
    return null;
}
 

@Override
void filter( Set<T> set ) {
    super.filter(set);
    for (Iterator<T> iterator = set.iterator(); iterator
            .hasNext();)
    {
        Element element = iterator.next();
        List<? extends AnnotationMirror> allAnnotationMirrors = getImplementation()
                .getHelper().getCompilationController().getElements()
                .getAllAnnotationMirrors(element);
        Set<String> qualifierNames = new HashSet<String>();
        for (AnnotationMirror annotationMirror : allAnnotationMirrors) {
            DeclaredType annotationType = annotationMirror
                    .getAnnotationType();
            TypeElement annotationElement = (TypeElement) annotationType
                    .asElement();
            if ( annotationElement == null ){
                continue;
            }
            String annotationName = annotationElement.getQualifiedName()
                .toString();
            if ( WebBeansModelProviderImpl.ANY_QUALIFIER_ANNOTATION.equals(
                    annotationName) || 
                    WebBeansModelProviderImpl.NAMED_QUALIFIER_ANNOTATION.equals(
                            annotationName))
            {
                continue;
            }
            if (isQualifier(annotationElement)) {
                qualifierNames.add(annotationName);
            }
        }
        if ( qualifierNames.contains(
                WebBeansModelProviderImpl.DEFAULT_QUALIFIER_ANNOTATION))
        {
            continue;
        }
        if ( (element instanceof TypeElement) && (
            AnnotationObjectProvider.checkSuper((TypeElement)element, 
                    WebBeansModelProviderImpl.DEFAULT_QUALIFIER_ANNOTATION, 
                    getImplementation().getHelper())!=null ))
        {
                continue;
        }
        else if ( element instanceof ExecutableElement ){
            Element specialized = 
                MemberCheckerFilter.getSpecialized( (ExecutableElement)element, 
                        getImplementation(), 
                        WebBeansModelProviderImpl.DEFAULT_QUALIFIER_ANNOTATION);
            if ( specialized!= null){
                continue;
            }
        }
        if (qualifierNames.size() != 0) {
            iterator.remove();
        }
    }
}
 

private static boolean isNonNullAnnotation(AnnotationMirror annotation) {
  Type annotationType = (Type) annotation.getAnnotationType();
  return JsInteropAnnotationUtils.isJsNonNullAnnotation(annotationType)
      || Ascii.equalsIgnoreCase(annotationType.asElement().getSimpleName().toString(), "Nonnull");
}
 

private Set<Element> getProductions( 
        List<AnnotationMirror> qualifierAnnotations, AtomicBoolean cancel) 
{
    List<Set<Element>> bindingCollections = 
        new ArrayList<Set<Element>>( qualifierAnnotations.size());
    /*
     * One need to handle special case with @Default annotation 
     * in case of specialization. There can be a case 
     * when production method doesn't explicitly declare @Default but 
     * specialize other method with several appropriate qualifiers.
     * In this case original method will have @Default along with 
     * qualifiers "inherited" from specialized methods.  
     */
    boolean hasDefault = getModel().getHelper().getAnnotationsByType( 
            qualifierAnnotations ).get(DEFAULT_QUALIFIER_ANNOTATION) != null ;
    Set<Element> currentBindings = new HashSet<Element>();
    for (AnnotationMirror annotationMirror : qualifierAnnotations) {
        if(cancel.get()) {
            currentBindings.clear();
            break;
        }
        DeclaredType type = annotationMirror.getAnnotationType();
        TypeElement annotationElement = (TypeElement)type.asElement();
        if ( annotationElement == null ){
            continue;
        }
        String annotationFQN = annotationElement.getQualifiedName().toString();
        findAnnotation( bindingCollections, annotationFQN , hasDefault,
                currentBindings, cancel);
    }

    if ( hasDefault ){
        bindingCollections.add( currentBindings );
    }
    
    Set<Element> result= null;
    for ( int i=0; i<bindingCollections.size() ; i++ ){
        Set<Element> list = bindingCollections.get(i);
        if ( i==0 ){
            result = list;
        }
        else {
            result.retainAll( list );
        }
    }
    if ( result == null ){
        return Collections.emptySet();
    }
    return result;
}
 

private RestEntity getParamEntity( CompilationController controller,
        Collection<TypeMirror> boxedPrimitives, 
        ExecutableElement methodElement, ExecutableType method )

{
    List<? extends VariableElement> parameters = methodElement.getParameters();
    int index=-1;
    int i=0;
    for (VariableElement variableElement : parameters) {
        List<? extends AnnotationMirror> annotationMirrors = 
            variableElement.getAnnotationMirrors();
        boolean isUriParam = false;
        for (AnnotationMirror annotationMirror : annotationMirrors) {
            DeclaredType annotationType = annotationMirror.getAnnotationType();
            Element annotationElement = annotationType.asElement();
            if ( annotationElement instanceof TypeElement ){
                String fqn = ((TypeElement)annotationElement).
                    getQualifiedName().toString();
                // skip arguments which are URI parameters ( query param or path param )
                if ( fqn.equals(RestConstants.QUERY_PARAM) || 
                        fqn.equals(RestConstants.PATH_PARAM))
                {
                    isUriParam = true;
                    break;
                }
            }
        }
        if ( !isUriParam ){
            index = i;
            break;
        }
        i++;
    }
    
    if ( index==-1 ){
        return new RestEntity(true);
    }
    List<? extends TypeMirror> parameterTypes = method.getParameterTypes();
    TypeMirror typeMirror = parameterTypes.get( index );
    return getRestEntity(controller, boxedPrimitives, typeMirror);
}
 

protected boolean hasAnyQualifier( VariableElement element,boolean injectRequired,
        boolean eventQualifiers, List<AnnotationMirror> quilifierAnnotations ) 
        throws InjectionPointDefinitionError
{
    List<? extends AnnotationMirror> annotations = 
        getModel().getHelper().getCompilationController().getElements().
        getAllAnnotationMirrors(element);
    boolean isProducer = false;
    
    /* Single @Any annotation means skip searching in qualifiers .
     * One need to check any bean that has required type .
     * @Any qualifier type along with other qualifiers 
     * equivalent to the same list of qualifiers without @Any.
     */
    boolean anyQualifier = false;
    
    boolean hasInject = false;
    
    for (AnnotationMirror annotationMirror : annotations) {
        DeclaredType type = annotationMirror.getAnnotationType();
        TypeElement annotationElement = (TypeElement)type.asElement();
        if ( annotationElement == null ){
            continue;
        }
        if ( ANY_QUALIFIER_ANNOTATION.equals( 
                annotationElement.getQualifiedName().toString()))
        {
            anyQualifier = true;
        }
        else if ( isQualifier( annotationElement , getModel().getHelper(),
                eventQualifiers) )
        {
            quilifierAnnotations.add( annotationMirror );
        }
        if ( PRODUCER_ANNOTATION.contentEquals( 
                annotationElement.getQualifiedName()))
        {
            isProducer = true;
        }
        else if ( INJECT_ANNOTATION.contentEquals( 
                annotationElement.getQualifiedName()))
        {
            hasInject = true;
        }
    }
    if ( isProducer ){
        throw new InjectionPointDefinitionError(
                NbBundle.getMessage( WebBeansModelProviderImpl.class, 
                        "ERR_ProducerInjectPoint" ,     // NOI18N
                        element.getSimpleName() ));
    }
    if ( element.asType().getKind() == TypeKind.TYPEVAR ){
        throw new InjectionPointDefinitionError(
                NbBundle.getMessage( WebBeansModelProviderImpl.class, 
                        "ERR_InjectPointTypeVar" ,           // NOI18N
                        element.getSimpleName() ));
    }
    if ( injectRequired ){
        checkInjectionPoint(element);
    }
    if ( injectRequired && !hasInject ){
        throw new InjectionPointDefinitionError(
                NbBundle.getMessage( WebBeansModelProviderImpl.class, 
                        "ERR_NoInjectPoint" ,           // NOI18N
                        element.getSimpleName() ));
    }
    return anyQualifier;
}
 

private static String getDeclaredScope( AnnotationModelHelper helper,
        List<? extends AnnotationMirror> annotationMirrors,
        ScopeChecker scopeChecker , NormalScopeChecker normalScopeChecker ,
        boolean singleScopeRequired ) throws CdiException
{
    List<? extends AnnotationMirror> annotations = annotationMirrors;
    if ( !singleScopeRequired ){
        annotations = new ArrayList<AnnotationMirror>( 
                annotationMirrors);
        Collections.reverse( annotations );
    }
    String scope = null;
    for (AnnotationMirror annotationMirror : annotations ) {
        String declaredScope = null;
        DeclaredType annotationType = annotationMirror.getAnnotationType();
        Element annotationElement = annotationType.asElement();
        if ( annotationElement instanceof TypeElement ){
            TypeElement annotation = (TypeElement)annotationElement;
            scopeChecker.init(annotation, helper );
            if ( scopeChecker.check() ){
                declaredScope = annotation.getQualifiedName().toString();
            }
            normalScopeChecker.init( annotation, helper );
            if ( normalScopeChecker.check() ){
                declaredScope = annotation.getQualifiedName().toString();
            }
            if ( declaredScope != null ){
                if ( !singleScopeRequired ){
                    return declaredScope;
                }
                if ( scope != null ){
                    throw new CdiException(NbBundle.getMessage(
                            ParameterInjectionPointLogic.class, 
                            "ERR_SeveralScopes"));                      // NOI18N
                }
                else {
                    scope = declaredScope;
                }
            }
        }
    }
    return scope;
}