src.java.compiler.share.classes.javax.lang.model.AnnotatedConstruct Maven / Gradle / Ivy
Show all versions of nb-javac-android Show documentation
/*
* Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.lang.model;
import java.lang.annotation.*;
import java.util.List;
import javax.lang.model.element.*;
import javax.lang.model.type.*;
/**
* Represents a construct that can be annotated.
*
* A construct is either an {@linkplain
* javax.lang.model.element.Element element} or a {@linkplain
* javax.lang.model.type.TypeMirror type}. Annotations on an element
* are on a declaration, whereas annotations on a type are on
* a specific use of a type name.
*
* As defined by The Java Language Specification
* section {@jls 9.7.4}, an annotation on an element is a
* declaration annotation and an annotation on a type is a
* type annotation.
*
* The terms directly present, present,
* indirectly present, and associated are used
* throughout this interface to describe precisely which annotations,
* either declaration annotations or type annotations, are returned by
* the methods in this interface.
*
* In the definitions below, an annotation A has an
* annotation type AT. If AT is a repeatable annotation
* type, the type of the containing annotation is ATC.
*
*
Annotation A is directly present on a construct
* C if either:
*
*
*
* - A is {@linkplain
* javax.lang.model.util.Elements#getOrigin(AnnotatedConstruct,
* AnnotationMirror) explicitly or implicitly}
* declared as applying to
* the source code representation of C.
*
*
Typically, if exactly one annotation of type AT appears in
* the source code of representation of C, then A is
* explicitly declared as applying to C.
*
* An annotation of type AT on a {@linkplain
* RecordComponentElement record component} can be implicitly propagated
* down to affiliated mandated members. Type annotations modifying the
* type of a record component can be also propagated to mandated
* members. Propagation of the annotations to mandated members is
* governed by rules given in the The Java Language
* Specification.
*
* If there are multiple annotations of type AT present on
* C, then if AT is repeatable annotation type, an
* annotation of type ATC is {@linkplain javax.lang.model.util.Elements#getOrigin(AnnotatedConstruct, AnnotationMirror) implicitly declared} on C.
*
- A representation of A appears in the executable output
* for C, such as the {@code RuntimeVisibleAnnotations} (JVMS {@jvms 4.7.16}) or
* {@code RuntimeVisibleParameterAnnotations} (JVMS {@jvms 4.7.17}) attributes of a class
* file.
*
*
*
* An annotation A is present on a
* construct C if either:
*
*
* - A is directly present on C.
*
*
- No annotation of type AT is directly present on
* C, and C is a class and AT is inheritable
* and A is present on the superclass of C.
*
*
*
* An annotation A is indirectly present on a construct
* C if both:
*
*
*
* - AT is a repeatable annotation type with a containing
* annotation type ATC.
*
*
- An annotation of type ATC is directly present on
* C and A is an annotation included in the result of
* calling the {@code value} method of the directly present annotation
* of type ATC.
*
*
*
* An annotation A is associated with a construct
* C if either:
*
*
*
* - A is directly or indirectly present on C.
*
*
- No annotation of type AT is directly or indirectly
* present on C, and C is a class, and AT is
* inheritable, and A is associated with the superclass of
* C.
*
*
*
* @since 1.8
* @jls 9.6 Annotation Interfaces
* @jls 9.6.4.3 {@code @Inherited}
* @jls 9.7.4 Where Annotations May Appear
* @jls 9.7.5 Multiple Annotations of the Same Interface
*/
public interface AnnotatedConstruct {
/**
* Returns the annotations that are directly present on
* this construct.
*
* @return the annotations directly present on this
* construct; an empty list if there are none
*/
List getAnnotationMirrors();
/**
* {@return this construct's annotation of the specified type if
* such an annotation is present, else {@code null}}
*
* The annotation returned by this method could contain an element
* whose value is of type {@code Class}.
* This value cannot be returned directly: information necessary to
* locate and load a class (such as the class loader to use) is
* not available, and the class might not be loadable at all.
* Attempting to read a {@code Class} object by invoking the relevant
* method on the returned annotation
* will result in a {@link MirroredTypeException},
* from which the corresponding {@link TypeMirror} may be extracted.
* Similarly, attempting to read a {@code Class[]}-valued element
* will result in a {@link MirroredTypesException}.
*
*
* Note: This method is unlike others in this and related
* interfaces. It operates on runtime reflective information —
* representations of annotation types currently loaded into the
* VM — rather than on the representations defined by and used
* throughout these interfaces. Consequently, calling methods on
* the returned annotation object can throw many of the exceptions
* that can be thrown when calling methods on an annotation object
* returned by core reflection. This method is intended for
* callers that are written to operate on a known, fixed set of
* annotation types.
*
*
* @param the annotation type
* @param annotationType the {@code Class} object corresponding to
* the annotation type
*
* @see #getAnnotationMirrors()
* @see java.lang.reflect.AnnotatedElement#getAnnotation
* @see EnumConstantNotPresentException
* @see AnnotationTypeMismatchException
* @see IncompleteAnnotationException
* @see MirroredTypeException
* @see MirroredTypesException
* @jls 9.6.1 Annotation Interface Elements
*/
A getAnnotation(Class annotationType);
/**
* Returns annotations that are associated with this construct.
*
* If there are no annotations associated with this construct, the
* return value is an array of length 0.
*
* The order of annotations which are directly or indirectly
* present on a construct C is computed as if indirectly present
* annotations on C are directly present on C in place of their
* container annotation, in the order in which they appear in the
* value element of the container annotation.
*
* The difference between this method and {@link #getAnnotation(Class)}
* is that this method detects if its argument is a repeatable
* annotation type, and if so, attempts to find one or more
* annotations of that type by "looking through" a container annotation.
*
* The annotations returned by this method could contain an element
* whose value is of type {@code Class}.
* This value cannot be returned directly: information necessary to
* locate and load a class (such as the class loader to use) is
* not available, and the class might not be loadable at all.
* Attempting to read a {@code Class} object by invoking the relevant
* method on the returned annotation
* will result in a {@link MirroredTypeException},
* from which the corresponding {@link TypeMirror} may be extracted.
* Similarly, attempting to read a {@code Class[]}-valued element
* will result in a {@link MirroredTypesException}.
*
*
* Note: This method is unlike others in this and related
* interfaces. It operates on runtime reflective information —
* representations of annotation types currently loaded into the
* VM — rather than on the representations defined by and used
* throughout these interfaces. Consequently, calling methods on
* the returned annotation object can throw many of the exceptions
* that can be thrown when calling methods on an annotation object
* returned by core reflection. This method is intended for
* callers that are written to operate on a known, fixed set of
* annotation types.
*
*
* @param the annotation type
* @param annotationType the {@code Class} object corresponding to
* the annotation type
* @return this construct's annotations for the specified annotation
* type if present on this construct, else an empty array
*
* @see #getAnnotationMirrors()
* @see #getAnnotation(Class)
* @see java.lang.reflect.AnnotatedElement#getAnnotationsByType(Class)
* @see EnumConstantNotPresentException
* @see AnnotationTypeMismatchException
* @see IncompleteAnnotationException
* @see MirroredTypeException
* @see MirroredTypesException
* @jls 9.6 Annotation Interfaces
* @jls 9.6.1 Annotation Interface Elements
*/
A[] getAnnotationsByType(Class annotationType);
}