Class AbstractAnnotationMetadataBuilder<T,A>

java.lang.Object
io.micronaut.inject.annotation.AbstractAnnotationMetadataBuilder<T,A>
Type Parameters:
T - The element type
A - The annotation type
Direct Known Subclasses:
GroovyAnnotationMetadataBuilder, JavaAnnotationMetadataBuilder, PythonAnnotationMetadataBuilder
@Internal public abstract class AbstractAnnotationMetadataBuilder<T,A> extends Object
An abstract implementation that builds AnnotationMetadata.
Since:
1.0
Author:
Graeme Rocher

  • Field Details

    • ELEMENT_VALIDATOR

      protected static final @Nullable AnnotatedElementValidator ELEMENT_VALIDATOR
      Names of annotations that should produce deprecation warnings. The key in the map is the deprecated annotation the value the replacement.

  • Constructor Details

    • AbstractAnnotationMetadataBuilder

      protected AbstractAnnotationMetadataBuilder()
      Default constructor.

  • Method Details

    • buildAnnotation

      public final Optional<AnnotationValue<?>> buildAnnotation(String annotationName)
      Builds an annotation value for the given annotation type name.
      Parameters:
      annotationName - The annotation name
      Returns:
      The built annotation value, if the annotation type can be resolved

    • getAnnotationDefaultValues

      public final Map<CharSequence, Object> getAnnotationDefaultValues(String annotationName)
      Resolves the default values declared by the given annotation type.
      Parameters:
      annotationName - The annotation type name
      Returns:
      The default values, or an empty map if the annotation type cannot be resolved
      Since:
      5.1.0

    • buildDeclared

      public AnnotationMetadata buildDeclared(T element)
      Build only metadata for declared annotations.
      Parameters:
      element - The element
      Returns:
      The AnnotationMetadata

    • lookupOrBuildForParameter

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuildForParameter(T declaringType, T methodElement, T parameterElement)
      Build the metadata for the given parameter element. The metadata is keyed by the type that declares the method, not by the type the method is reached through: a parameter of an inherited method is the same parameter whether it is read through the declaring class or through a subclass, so a mutation made through one must be visible through the other. Unlike a method, a parameter's metadata never includes the owning type's annotations, so nothing distinguishes it per owner.
      Parameters:
      declaringType - The type declaring the method
      methodElement - The method element
      parameterElement - The parameter element
      Returns:
      The AnnotationMetadata

    • lookupOrBuildForType

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuildForType(T typeElement)
      Build the metadata for the given element.
      Parameters:
      typeElement - The element
      Returns:
      The AnnotationMetadata

    • lookupOrBuildForMethod

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuildForMethod(T owningType, T element)
      Build the metadata for the given method element excluding any class metadata.
      Parameters:
      owningType - The owningType
      element - The element
      Returns:
      The AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata

    • lookupOrBuildForField

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuildForField(T declaringType, T element)
      Build the metadata for the given field element excluding any class metadata. The metadata is keyed by the type that declares the field, not by the type the field is reached through: an inherited field is the same field whether it is read through the declaring class or through a subclass, so a mutation made through one must be visible through the other.
      Parameters:
      declaringType - The type declaring the field
      element - The element
      Returns:
      The AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata

    • lookupOrBuildForField

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuildForField(T owningType, T declaringType, T element, boolean propertyComponent)
      Build the metadata for the given field element read through the given owning type, excluding any class metadata. A mutation made on the field itself is keyed by the declaring type, as with lookupOrBuildForField(Object, Object), and is visible through every type the field is read through. A mutation made on the field as a component of a bean property belongs to the owning type: a bean property is resolved for the type it is read through, as its accessor methods are, so annotating the property of a super type must not annotate the same property read through a subclass. Once the owning type holds such a mutation, the field read or mutated through the owning type uses it.
      Parameters:
      owningType - The type the field is read through
      declaringType - The type declaring the field
      element - The element
      propertyComponent - Whether a mutation is made on the field as a component of a bean property
      Returns:
      The AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata
      Since:
      5.2.1

    • lookupOrBuildForOwner

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuildForOwner(Object sharedKey, Object ownerKey, T element, boolean ownerMutation)
      Lookup or build the metadata of a member shared by the types it is read through, keeping the mutations made for one owning type apart from the shared metadata.
      Parameters:
      sharedKey - The cache key of the metadata shared by every owning type
      ownerKey - The cache key of the metadata mutated for the owning type
      element - The element
      ownerMutation - Whether a mutation belongs to the owning type
      Returns:
      The AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata
      Since:
      5.2.1
      See Also:

    • lookupOrBuild

      public AbstractAnnotationMetadataBuilder.CachedAnnotationMetadata lookupOrBuild(Object key, T element)
      Lookup or build new annotation metadata.
      Parameters:
      key - The cache key
      element - The type element
      Returns:
      The annotation metadata
      Since:
      4.0.0

    • buildInternal

      protected final AnnotationMetadata buildInternal(T element)

    • getTypeForAnnotation

      protected abstract T getTypeForAnnotation(A annotationMirror)
      Get the type of the given annotation.
      Parameters:
      annotationMirror - The annotation
      Returns:
      The type

    • hasAnnotation

      protected abstract boolean hasAnnotation(T element, Class<? extends Annotation> annotation)
      Checks whether an annotation is present.
      Parameters:
      element - The element
      annotation - The annotation type
      Returns:
      True if the annotation is present

    • hasAnnotation

      protected abstract boolean hasAnnotation(T element, String annotation)
      Checks whether an annotation is present.
      Parameters:
      element - The element
      annotation - The annotation type name
      Returns:
      True if the annotation is present

    • hasAnnotations

      protected abstract boolean hasAnnotations(T element)
      Checks whether any annotations are present on the given element.
      Parameters:
      element - The element
      Returns:
      True if the annotation is present

    • getAnnotationTypeName

      protected abstract String getAnnotationTypeName(A annotationMirror)
      Get the given type of the annotation.
      Parameters:
      annotationMirror - The annotation
      Returns:
      The type

    • getElementName

      protected abstract String getElementName(T element)
      Get the name for the given element.
      Parameters:
      element - The element
      Returns:
      The name

    • getAnnotationsForType

      protected abstract List<? extends A> getAnnotationsForType(T element)
      Obtain the annotations for the given type. This method is also responsible for unwrapping repeatable annotations.

      For example, @Parent(value = {@Child, @Child}) should result in the two child annotations being returned from this method instead of the parent annotation.

      Parameters:
      element - The type element
      Returns:
      The annotations

    • buildHierarchy

      protected abstract List<T> buildHierarchy(T element, boolean inheritTypeAnnotations, boolean declaredOnly)
      Build the type hierarchy for the given element.
      Parameters:
      element - The element
      inheritTypeAnnotations - Whether to inherit type annotations
      declaredOnly - Whether to only include declared annotations
      Returns:
      The type hierarchy

    • readAnnotationRawValues

      protected abstract void readAnnotationRawValues(T originatingElement, String annotationName, T member, String memberName, Object annotationValue, Map<CharSequence, Object> annotationValues)
      Read the given member and value, applying conversions if necessary, and place the data in the given map.
      Parameters:
      originatingElement - The originating element
      annotationName - The annotation name
      member - The member being read from
      memberName - The member
      annotationValue - The value
      annotationValues - The values to populate

    • readAnnotationRawValues

      protected void readAnnotationRawValues(T originatingElement, String annotationName, T member, String memberName, Object annotationValue, Map<CharSequence, Object> annotationValues, Map<String, Map<CharSequence, Object>> resolvedDefaults)
      Read the given member and value, applying conversions if necessary, and place the data in the given map.
      Parameters:
      originatingElement - The originating element
      annotationName - The annotation name
      member - The member being read from
      memberName - The member
      annotationValue - The value
      annotationValues - The values to populate
      resolvedDefaults - The resolved defaults
      Since:
      4.3.0

    • validateAnnotationValue

      protected void validateAnnotationValue(T originatingElement, String annotationName, T member, String memberName, Object resolvedValue)
      Validates an annotation value.
      Parameters:
      originatingElement - The originating element
      annotationName - The annotation name
      member - The member
      memberName - The member name
      resolvedValue - The resolved value

    • isValidationRequired

      protected abstract boolean isValidationRequired(T member)
      Return whether the given member requires validation.
      Parameters:
      member - The member
      Returns:
      True if it is

    • getElementValidator

      protected @Nullable AnnotatedElementValidator getElementValidator()
      Obtains the element validator.
      Returns:
      The validator.

    • addError

      protected abstract void addError(T originatingElement, String error)
      Adds an error.
      Parameters:
      originatingElement - The originating element
      error - The error

    • addWarning

      protected abstract void addWarning(T originatingElement, String warning)
      Adds a warning.
      Parameters:
      originatingElement - The originating element
      warning - The warning

    • readAnnotationValue

      protected abstract Object readAnnotationValue(T originatingElement, T member, String annotationName, String memberName, Object annotationValue)
      Read the given member and value, applying conversions if necessary, and place the data in the given map.
      Parameters:
      originatingElement - The originating element
      member - The member
      annotationName - The annotation name
      memberName - The member name
      annotationValue - The value
      Returns:
      The object

    • readAnnotationDefaultValues

      protected abstract Map<? extends T, ?> readAnnotationDefaultValues(String annotationName, T annotationType)
      Read the raw default annotation values from the given annotation.
      Parameters:
      annotationName - annotation name
      annotationType - the type
      Returns:
      The values

    • readAnnotationDefaultValues

      protected Map<? extends T, ?> readAnnotationDefaultValues(String annotationName, T annotationType, boolean includeEmptyValues)
      Read the raw default annotation values from the given annotation.

      Implementations must report a default for every member that declares one, whatever the shape of the default expression: a constant, an enum constant, a class literal, an array literal (including the empty array) or a nested annotation.

      includeEmptyValues only concerns the empty string: when it is not set, a member whose default is the empty string is reported as having no default, which keeps the written annotation metadata smaller. An empty array default is always reported. See JavaAnnotationMetadataBuilder#isValidDefaultValue for the rationale. All language implementations must apply this rule identically.

      Parameters:
      annotationName - annotation name
      annotationType - the type
      includeEmptyValues - Whether empty values should be included
      Returns:
      The values
      Since:
      5.1.0

    • readAnnotationRawValues

      protected abstract Map<? extends T, ?> readAnnotationRawValues(A annotationMirror)
      Read the raw annotation values from the given annotation.
      Parameters:
      annotationMirror - The annotation
      Returns:
      The values

    • getAnnotationValues

      protected abstract <K extends Annotation> Optional<AnnotationValue<K>> getAnnotationValues(T originatingElement, T member, Class<K> annotationType)
      Resolve the annotations values from the given member for the given type.
      Type Parameters:
      K - The annotation type
      Parameters:
      originatingElement - The originating element
      member - The member
      annotationType - The type
      Returns:
      The values

    • getAnnotationMemberName

      protected abstract String getAnnotationMemberName(T member)
      Read the name of an annotation member.
      Parameters:
      member - The member
      Returns:
      The name

    • getRepeatableName

      protected abstract @Nullable String getRepeatableName(A annotationMirror)
      Obtain the name of the repeatable annotation if the annotation is one.
      Parameters:
      annotationMirror - The annotation mirror
      Returns:
      Return the name or null

    • getRepeatableContainerNameForType

      protected abstract @Nullable String getRepeatableContainerNameForType(T annotationType)
      Obtain the name of the repeatable annotation if the annotation is one.
      Parameters:
      annotationType - The annotation mirror
      Returns:
      Return the name or null

    • readNestedAnnotationValue

      protected AnnotationValue<?> readNestedAnnotationValue(T annotationElement, A annotationType)
      Parameters:
      annotationElement - The annotation element
      annotationType - The annotation type
      Returns:
      The annotation value

    • readNestedAnnotationValue

      protected AnnotationValue<?> readNestedAnnotationValue(T annotationElement, A annotationType, Map<String, Map<CharSequence, Object>> resolvedDefaults)
      Parameters:
      annotationElement - The annotation element
      annotationType - The annotation type
      resolvedDefaults - resoldved defaults
      Returns:
      The annotation value

    • getAnnotationMirror

      protected abstract Optional<T> getAnnotationMirror(String annotationName)
      Return a mirror for the given annotation.
      Parameters:
      annotationName - The annotation name
      Returns:
      An optional mirror

    • isEvaluatedExpression

      protected boolean isEvaluatedExpression(@Nullable Object value)
      Detect evaluated expression in annotation value.
      Parameters:
      value - - Annotation value
      Returns:
      if value contains evaluated expression

    • buildEvaluatedExpressionReference

      protected Object buildEvaluatedExpressionReference(T originatingElement, String annotationName, String memberName, Object initialAnnotationValue)
      Wraps original annotation value to make it processable at later stages.
      Parameters:
      originatingElement - originating annotated element
      annotationName - annotation name
      memberName - annotation member name
      initialAnnotationValue - original annotation value
      Returns:
      expression reference

    • getOriginatingClassName

      protected abstract @Nullable String getOriginatingClassName(T orginatingElement)

    • getAnnotationMember

      protected abstract @Nullable T getAnnotationMember(T annotationElement, CharSequence member)
      Get the annotation member.
      Parameters:
      annotationElement - The annotation element
      member - The member
      Returns:
      The annotation member element

    • getAnnotationMappers

      protected <K extends Annotation> @Nullable List<AnnotationMapper<K>> getAnnotationMappers(String annotationName)
      Obtain the annotation mappers for the given annotation name.
      Type Parameters:
      K - The annotation type
      Parameters:
      annotationName - The annotation name
      Returns:
      The mappers

    • getAnnotationTransformers

      protected <K extends Annotation> @Nullable List<AnnotationTransformer<K>> getAnnotationTransformers(String annotationName)
      Obtain the transformers mappers for the given annotation name.
      Type Parameters:
      K - The annotation type
      Parameters:
      annotationName - The annotation name
      Returns:
      The transformers

    • getAnnotationRemappers

      protected List<AnnotationRemapper> getAnnotationRemappers(String packageName)
      Obtain the remappers for the given annotation package.
      Parameters:
      packageName - The annotation package
      Returns:
      The remappers
      Since:
      5.2.0

    • getVisitorContext

      protected abstract VisitorContext getVisitorContext()
      Returns the visitor context for this implementation.
      Returns:
      The visitor context

    • getRetentionPolicy

      protected abstract RetentionPolicy getRetentionPolicy(T annotation)
      Gets the retention policy for the given annotation.
      Parameters:
      annotation - The annotation
      Returns:
      The retention policy

    • getRetentionPolicy

      public RetentionPolicy getRetentionPolicy(String annotation)
      Gets the retention policy for the given annotation.
      Parameters:
      annotation - The annotation
      Returns:
      The retention policy

    • postProcess

      protected void postProcess(MutableAnnotationMetadata mutableAnnotationMetadata, T element)

    • getCachedAnnotationDefaults

      protected Map<CharSequence, Object> getCachedAnnotationDefaults(String annotationName, T annotationType)
      Get the cached annotation defaults.
      Parameters:
      annotationName - The annotation name
      annotationType - The annotation type
      Returns:
      The defaults

    • isRepeatableAnnotationContainer

      protected boolean isRepeatableAnnotationContainer(AnnotationValue<?> annotationValue)
      Parameters:
      annotationValue - The annotation value
      Returns:
      true if the annotation is a repeatable container

    • findRepeatableContainerNameForType

      protected @Nullable String findRepeatableContainerNameForType(String annotationName)
      Find the repeatable container for given annotation type.
      Parameters:
      annotationName - The repeatable annotation
      Returns:
      The repeatable container if exists

    • isExcludedAnnotation

      protected boolean isExcludedAnnotation(T element, String annotationName)
      Is the given annotation excluded for the specified element.
      Parameters:
      element - The element
      annotationName - The annotation name
      Returns:
      True if it is excluded

    • clearMutated

      @Internal public static void clearMutated()
      Used to clear mutated metadata at the end of a compilation cycle.

    • clearMutated

      @Internal public static void clearMutated(Object key)
      Used to clear mutated metadata at the end of a compilation cycle.
      Parameters:
      key - The mutated annotation metadata to remove

    • clearProcessedAnnotationTypes

      @Internal public void clearProcessedAnnotationTypes()
      Forgets the annotation types remembered during the processing, which are the fallback used to derive the aliases of an annotation the retained tree holds and to decide whether one is Retainable.

      An implementation that rebuilds its builder for every processing round need not call this. One that reuses a builder across rounds has to call it at the boundary: the entries are native elements of the session that has ended, and the map is keyed by annotation name, so a later round would hit and be handed a dead element rather than miss.

    • clearCaches

      @Internal public static void clearCaches()
      Used to clear caches at the end of a compilation cycle.

    • copyToRuntime

      @Internal public static void copyToRuntime()
      This is used for testing scenarios only where annotation metadata is created without bean creation. It is needed because at compile time there are no defaults added via DefaultAnnotationMetadata.

    • getMappedAnnotationNames

      @Internal public static Set<String> getMappedAnnotationNames()
      Returns:
      Additional mapped annotation names

    • getMappedAnnotationPackages

      @Internal public static Set<String> getMappedAnnotationPackages()
      Returns:
      Additional mapped annotation names

    • annotate

      public <A2 extends Annotation> AnnotationMetadata annotate(AnnotationMetadata annotationMetadata, AnnotationValue<A2> annotationValue)
      Annotate an existing annotation metadata object.
      Type Parameters:
      A2 - The annotation type
      Parameters:
      annotationMetadata - The annotation metadata
      annotationValue - The annotation value
      Returns:
      The mutated metadata

    • removeAnnotation

      public AnnotationMetadata removeAnnotation(AnnotationMetadata annotationMetadata, String annotationType)
      Removes an annotation from the given annotation metadata.
      Parameters:
      annotationMetadata - The annotation metadata
      annotationType - The annotation type
      Returns:
      The updated metadata
      Since:
      3.0.0

    • removeStereotype

      public AnnotationMetadata removeStereotype(AnnotationMetadata annotationMetadata, String annotationType)
      Removes an annotation from the given annotation metadata.
      Parameters:
      annotationMetadata - The annotation metadata
      annotationType - The annotation type
      Returns:
      The updated metadata
      Since:
      3.0.0

    • removeAnnotationIf

      public <T1 extends Annotation> AnnotationMetadata removeAnnotationIf(AnnotationMetadata annotationMetadata, Predicate<AnnotationValue<T1>> predicate)
      Removes an annotation from the metadata for the given predicate.
      Type Parameters:
      T1 - The annotation type
      Parameters:
      annotationMetadata - The annotation metadata
      predicate - The predicate
      Returns:
      The potentially modified metadata