All Classes and Interfaces
Class
Description
Exception thrown when annotation processing should be aborted for the current class.
A utility class for working with
AnnotationMirror instances.Handling of default values for annotation members.
Visitor that produces a string representation of an annotation value, suitable for inclusion in
a Java source file as an annotation member or as the initializer of a variable of the
appropriate type.
A utility class for working with
AnnotationValue instances.Annotation that causes an implementation of an annotation interface to be generated.
Javac annotation processor (compiler plugin) to generate annotation implementations.
The variables to substitute into the autoannotation.vm template.
Specifies that the annotated class is a one-of class, also known as a tagged union.
Javac annotation processor (compiler plugin) for one-of types; user code never references this class.
The variables to substitute into the autooneof.vm template.
An annotation for service providers as described in
ServiceLoader.Processes
AutoService annotations and generates the service provider
configuration files described in ServiceLoader.Specifies that AutoValue should generate an implementation of the annotated class or interface,
to serve as a builder for the value-type class it is nested within.
Specifies that AutoValue should copy any annotations from the annotated element to the
generated class.
Annotation processor that checks that the type that
AutoValue.Builder is applied to is
nested inside an @AutoValue class.An AutoValueExtension allows for extra functionality to be created during the generation of an
AutoValue class.
The context of the generation cycle.
Shared code between AutoValueProcessor and AutoOneOfProcessor.
A property of an
@AutoValue or @AutoOneOf class, defined by one of its abstract
methods.The variables to substitute into the autovalue.vm or autooneof.vm template.
Javac annotation processor (compiler plugin) for value types; user code never references this
class.
The variables to substitute into the autovalue.vm template.
A package or type name.
The unit of processing logic that runs under the guarantee that all elements are complete and
well-formed.
Classifies methods inside builder types, based on their names and parameter and return types.
Support for AutoValue builders.
Information about a builder property getter, referenced from the autovalue.vm template.
Information about a property setter, referenced from the autovalue.vm template.
Names of classes that are referenced in the processor/extension.
Names of classes that are referenced in the processors.
A node in the parse tree representing a constant value.
A node in the parse tree that is a directive such as
#set ($x = $y)
or #if ($x) y #end.A node in the parse tree representing a
#foreach construct.This class is the type of the variable
$foreach that is defined within
#foreach loops.A node in the parse tree representing an
#if construct.A node in the parse tree representing a macro call.
A node in the parse tree representing a
#set construct.Hacks needed to work around various bugs and incompatibilities in Eclipse's implementation of
annotation processing.
Handle error reporting for an annotation processor.
The context of a template evaluation.
An exception that occurred while evaluating a template, such as an undefined variable reference
or a division by zero.
A node in the parse tree representing an expression.
Represents all binary expressions.
A node in the parse tree representing an expression like
!$a.Utility methods for writing
@Generated annotations.Utility methods for writing
@Generated annotations using JavaPoet.Generates GWT serialization code for
@AutoValue classes also marked
@GwtCompatible(serializable = true).A simplistic Java scanner.
A macro definition.
The context for evaluation within macros.
Annotates methods in
@AutoValue classes for which the
generated subclass will memoize the
returned value.An annotation
Processor that reports errors for @Memoized methods that
are not inside AutoValue-annotated classes.An extension that implements the
Memoized contract.Exception thrown in the specific case where processing of a class was abandoned because it
required types that the class references to be present and they were not.
Static utility methods pertaining to
Element instances.Utilities related to
TypeMirror instances.A node in the parse tree.
A wrapper for properties of Optional-like classes.
Determines if one method overrides another.
An exception that occurred while parsing a template.
Classifies methods inside builder types that return builders for properties.
Information about a property builder, referenced from the autovalue.vm template.
A node in the parse tree that is a reference.
A node in the parse tree that is an indexing of a reference, like
$x[0] or
$x.foo[$i].A node in the parse tree that is a reference to a property of another reference, like
$x.foo or $x[$i].foo.A node in the parse tree representing a method reference, like
$list.size().A node in the parse tree that is a plain reference such as
$x.Postprocessor that runs over the output of the template engine in order to make it look nicer.
The second phase of parsing.
A helper class for reading and writing Services files.
A simple implementation of the
AnnotationMirror interface.A method on an
@AutoValue or AutoOneOf class that has no specific attached
information, such as a toBuilder() method, or a build() method, where only the
name and access type is needed in context.A simple implementation of the
AnnotationValue interface for a class literal, e.g.A utility class that traverses
Element instances and ensures that all type information
is present and resolvable.A template expressed in EscapeVelocity, a subset of the Velocity Template Language (VTL) from
Apache.
Used to resolve references to resources in the template, through
#parse directives.A template and a set of variables to be substituted into that template.
A parsing node that will be deleted during the construction of the parse tree, to be replaced
by a higher-level construct such as
DirectiveNode.IfNode.A node in the parse tree representing a comment.
A synthetic node that represents the end of the input.
Encodes types so they can later be decoded to incorporate imports.
Like
TypeEncoder.EncodingTypeVisitor except that annotations on the visited type are also included
in the resultant string.Converts a type into a string, using standard Java syntax, except that every class name is
wrapped in backquotes, like
`java.util.List`.Like
TypeEncoder.EncodingTypeVisitor except that type parameters are omitted from the result.A set of TypeMirror objects.
Takes a set of types and a package and determines which of those types can be imported, and how
to spell any of the types in the set given those imports.
Visitor that tells whether a type is erased, in the sense of
TypeSimplifier.isCastingUnchecked(javax.lang.model.type.TypeMirror).The spelling that should be used to refer to a given class, and an indication of whether it
should be imported.
Represents the visibility of a given
Element: public, protected,
private or default/package-private.