Represents an annotation.  An annotation associates a value with
each element of an annotation type.

 Annotations should be compared using the equals
method.  There is no guarantee that any particular annotation will
always be represented by the same object.

Represents a value of an annotation type element.
A value is of one of the following types:
 a wrapper class (such as Integer) for a primitive type
     String
     TypeMirror
     VariableElement (representing an enum constant)
     AnnotationMirror
     List<? extends AnnotationValue>
             (representing the elements, in declared order, if the value is an array)

A visitor of the values of annotation type elements, using a
variant of the visitor design pattern.  Unlike a standard visitor
which dispatches based on the concrete type of a member of a type
hierarchy, this visitor dispatches based on the type of data
stored; there are no distinct subclasses for storing, for example,
boolean values versus int values.  Classes
implementing this interface are used to operate on a value when the
type of that value is unknown at compile time.  When a visitor is
passed to a value's accept method,
the visitXYZ method applicable to that value is
invoked.

 Classes implementing this interface may or may not throw a
NullPointerException if the additional parameter p
is null; see documentation of the implementing class for
details.

 WARNING: It is possible that methods will be added to
this interface to accommodate new, currently unknown, language
structures added to future versions of the Java™ programming
language.  Therefore, visitor classes directly implementing this
interface may be source incompatible with future versions of the
platform.  To avoid this source incompatibility, visitor
implementations are encouraged to instead extend the appropriate
abstract visitor class that implements this interface.  However, an
API should generally use this visitor interface as the type for
parameters, return type, etc. rather than one of the abstract
classes.

Note that methods to accommodate new language constructs could
be added in a source compatible way if they were added as
default methods.  However, default methods are only
available on Java SE 8 and higher releases and the javax.lang.model.* packages bundled in Java SE 8 are required to
also be runnable on Java SE 7.  Therefore, default methods
cannot be used when extending javax.lang.model.*
to cover Java SE 8 language features.  However, default methods may
be used in subsequent revisions of the javax.lang.model.*
packages that are only required to run on Java SE 8 and higher
platform versions.

Represents a program element such as a package, class, or method.
Each element represents a static, language-level construct
(and not, for example, a runtime construct of the virtual machine).

 Elements should be compared using the equals(Object)
method.  There is no guarantee that any particular element will
always be represented by the same object.

 To implement operations based on the class of an Element object, either use a javax.lang.model.element.visitor or
use the result of the getKind() method.  Using instanceof is not necessarily a reliable idiom for
determining the effective class of an object in this modeling
hierarchy since an implementation may choose to have a single object
implement multiple Element subinterfaces.

A visitor of program elements, in the style of the visitor design
pattern.  Classes implementing this interface are used to operate
on an element when the kind of element is unknown at compile time.
When a visitor is passed to an element's accept method, the visitXYZ method most applicable
to that element is invoked.

 Classes implementing this interface may or may not throw a
NullPointerException if the additional parameter p
is null; see documentation of the implementing class for
details.

 WARNING: It is possible that methods will be added to
this interface to accommodate new, currently unknown, language
structures added to future versions of the Java™ programming
language.  Therefore, visitor classes directly implementing this
interface may be source incompatible with future versions of the
platform.  To avoid this source incompatibility, visitor
implementations are encouraged to instead extend the appropriate
abstract visitor class that implements this interface.  However, an
API should generally use this visitor interface as the type for
parameters, return type, etc. rather than one of the abstract
classes.

Note that methods to accommodate new language constructs could
be added in a source compatible way if they were added as
default methods.  However, default methods are only
available on Java SE 8 and higher releases and the javax.lang.model.* packages bundled in Java SE 8 are required to
also be runnable on Java SE 7.  Therefore, default methods
cannot be used when extending javax.lang.model.*
to cover Java SE 8 language features.  However, default methods may
be used in subsequent revisions of the javax.lang.model.*
packages that are only required to run on Java SE 8 and higher
platform versions.

Represents a method, constructor, or initializer (static or
instance) of a class or interface, including annotation type
elements.

An immutable sequence of characters.  When created by the same
implementation, objects implementing this interface must obey the
general equals contract when compared
with each other.  Therefore, Name objects from the same
implementation are usable in collections while Names from
different implementations may not work properly in collections.

An empty Name has a length of zero.

In the context of javax.annotation.processing.annotation
processing, the guarantees for "the same" implementation must
include contexts where the API mediated side effects of javax.annotation.processing.processors could be visible
to each other, including successive annotation processing
javax.annotation.processing.rounds.

Represents a package program element.  Provides access to information
about the package and its members.

A mixin interface for an element that has type parameters.

A mixin interface for an element that has a qualified name.

Represents a class or interface program element.  Provides access
to information about the type and its members.  Note that an enum
type is a kind of class and an annotation type is a kind of
interface.


While a TypeElement represents a class or interface
element, a DeclaredType represents a class
or interface type, the latter being a use
(or invocation) of the former.
The distinction is most apparent with generic types,
for which a single element can define a whole
family of types.  For example, the element
java.util.Set corresponds to the parameterized types
java.util.Set<String> and java.util.Set<Number>
(and many others), and to the raw type java.util.Set.

 Each method of this interface that returns a list of elements
will return them in the order that is natural for the underlying
source of program information.  For example, if the underlying
source of information is Java source code, then the elements will be
returned in source code order.

Represents a formal type parameter of a generic class, interface, method,
or constructor element.
A type parameter declares a TypeVariable.

Indicates that an unknown kind of annotation value was encountered.
This can occur if the language evolves and new kinds of annotation
values can be stored in an annotation.  May be thrown by an
javax.lang.model.element.annotation value visitor to
indicate that the visitor was created for a prior version of the
language.

Indicates that an unknown kind of element was encountered.  This
can occur if the language evolves and new kinds of elements are
added to the Element hierarchy.  May be thrown by an
javax.lang.model.element.element visitor to indicate that the
visitor was created for a prior version of the language.

Represents a field, enum constant, method or constructor
parameter, local variable, resource variable, or exception
parameter.