Java Code Examples for java.lang.annotation.ElementType#FIELD

@Override
protected void visitConfigTypeAnnotation(final UAnnotation node, final UClass owner) {
	final List<UAnnotation> annotations = ((UAnnotated) owner).getAnnotations();
	for (UAnnotation annotation : annotations) {
		if (!isTargetAnnotation(annotation)) {
			continue;
		}

		final ElementType[] annotationTargets = getTargetValue(annotation);
		if (annotationTargets.length == 1 && annotationTargets[0] == ElementType.FIELD) {
			return;
		}
	}

	reportPsi(owner.getNameIdentifier());
}
 

/**
 * Construct an instance. It initially contains no elements.
 *
 * @param declaringType    the type declaring the program element.
 * @param type             the annotation type.
 * @param annotatedElement the program element type to be annotated.
 * @return an annotation {@code AnnotationId<D,V>} instance.
 */
public static <D, V> AnnotationId<D, V> get(TypeId<D> declaringType, TypeId<V> type,
                                            ElementType annotatedElement) {
    if (annotatedElement != ElementType.TYPE &&
            annotatedElement != ElementType.METHOD &&
            annotatedElement != ElementType.FIELD &&
            annotatedElement != ElementType.PARAMETER) {
        throw new IllegalArgumentException("element type is not supported to annotate yet.");
    }

    return new AnnotationId<>(declaringType, type, annotatedElement);
}
 

public static void addToField(DexMaker dexMaker, FieldId<?, ?> field,List<AnnotationId<?,?>> ids) {
    ClassDefItem classDefItem = dexMaker.getTypeDeclaration(field.declaringType).toClassDefItem();
    if (classDefItem == null) {
        throw new NullPointerException("No class defined item is found");
    }
    Annotations annotations = new Annotations();
    for (AnnotationId<?,?> id:ids){
        if (id.annotatedElement != ElementType.FIELD) {
            throw new IllegalStateException("This annotation is not for method");
        }

        if (field.declaringType != id.declaringType) {
            throw new IllegalArgumentException("Field" + field + "'s declaring type is inconsistent with" + id);
        }

        // Generate CstType
        CstType cstType = CstType.intern(id.type.ropType);

        // Generate Annotation
        Annotation annotation = new Annotation(cstType, AnnotationVisibility.RUNTIME);

        // Add generated annotation
        for (NameValuePair nvp : id.elements.values()) {
            annotation.add(nvp);
        }
        annotations.add(annotation);
    }

    CstFieldRef cstFieldRef = field.constant;
    classDefItem.addFieldAnnotations(cstFieldRef, annotations, dexMaker.getDexFile());
}
 

/** Start ElementType Type Related Action Test */
@Test
public void callPublicMethodWithElementTypeParam() {
    Assert.assertNull(controller.getModel().getEnumValue());
    final ElementType value = ElementType.FIELD;
    controller.invoke(PUBLIC_WITH_ELEMENT_TYPE_PARAM_ACTION, new Param(PARAM_NAME, value));
    Assert.assertEquals(controller.getModel().getEnumValue(), value);
}
 

/**
 *  Construct an instance. It initially contains no elements.
 *
 * @param declaringType the type declaring the program element.
 * @param type the annotation type.
 * @param annotatedElement the program element type to be annotated.
 * @return an annotation {@code AnnotationId<D,V>} instance.
 */
public static <D, V> AnnotationId<D, V> get(TypeId<D> declaringType, TypeId<V> type,
                                            ElementType annotatedElement) {
    if (annotatedElement != ElementType.TYPE &&
            annotatedElement != ElementType.METHOD &&
            annotatedElement != ElementType.FIELD &&
            annotatedElement != ElementType.PARAMETER) {
        throw new IllegalArgumentException("element type is not supported to annotate yet.");
    }

    return new AnnotationId<>(declaringType, type, annotatedElement);
}
 

@Override
public ElementType getElementType() {
    return ElementType.FIELD;
}
 

@Override
public ElementType getElementType() {
    return ElementType.FIELD;
}
 

private void parseBindPreference(Element annotatedElement) {
    if (bindPreferenceAnnotationHasError(annotatedElement)) {
        return;
    }

    // Assemble information on the binding point.
    final TypeElement enclosingElement = (TypeElement) annotatedElement.getEnclosingElement();
    final BindPref annotation = annotatedElement.getAnnotation(BindPref.class);
    final String[] preferenceKeys = annotation.value();
    final String name = annotatedElement.getSimpleName().toString();

    final boolean isField = annotatedElement.getKind().isField();
    final ElementType elementType = isField?ElementType.FIELD:ElementType.METHOD;
    String type;

    if(!annotation.init() && !annotation.listen()) {
        error(annotatedElement, "@BindPref binding has no effect (it should either initialize or listen)", enclosingElement.getQualifiedName(), name);
        return;
    } else if(preferenceKeys.length == 0) {
        error(annotatedElement, "Missing preference key(s) for @BindPref annotation", enclosingElement.getQualifiedName(), name);
        return;
    } else if(isField){
        if(preferenceKeys.length > 1) {
            error(annotatedElement, "Multiple preference keys are only allowed for @BindPref method annotations (not fields)", enclosingElement.getQualifiedName(), name);
            return;
        }

        if(annotation.bindTo().prefType == null) {
            type = annotatedElement.asType().toString();
        } else {
            type = annotation.bindTo().prefType.getFieldTypeDef();
        }
    }else {
        // Assemble information on the binding point.
        ExecutableElement executableElement = (ExecutableElement) annotatedElement;
        List<? extends VariableElement> params = executableElement.getParameters();

        if(annotation.bindTo() != WidgetBindingType.ASSIGN) {
            error(annotatedElement, "@BindPref method annotations should not use the \"bindTo\" property", enclosingElement.getQualifiedName(), name);
            return;
        } else if(preferenceKeys.length > 1) {
            if(params.size() > 0) {
                error(annotatedElement, "@BindPref method annotations with multiple preference keys can not have method parameters", enclosingElement.getQualifiedName(), name);
                return;
            }
            type = null;
        }else if(params.size() != 1) {
            error(annotatedElement,
                    "Methods annotated with @BindPref must have a single parameter. (%s.%s)",
                    enclosingElement.getQualifiedName(),
                    name);
            return;
        }else {
            type = params.get(0).asType().toString();
        }
    }

    BinderClassFactory binder = getOrCreateTargetClass(enclosingElement);
    Binding binding = new Binding(name, type, elementType, annotation.bindTo());

    for(String preferenceKey : preferenceKeys) {
        if(annotation.init()) {
            binder.addInitBinding(preferenceKey, binding);
        }
        if (annotation.listen()) {
            binder.addListenerBinding(preferenceKey, binding);
        }
    }

    // Add the type-erased version to the valid binding targets set.
    targetClassNames.add(enclosingElement.toString());
}