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 class for the annotated abstract class, implementing the standard Object methods like equals to have conventional value semantics.
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.
An abstract Processor implementation that defers processing of Elements to later rounds if they cannot be processed.
A package or type name.
 
Deprecated.
 
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
invalid reference
@Memoized
methods that are not inside AutoValue-annotated classes.
An extension that implements the
invalid reference
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.
 
 
 
Visitor that tells whether a type is erased, in the sense of
invalid reference
#castIsUnchecked
.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
A parser that reads input from the given Reader and parses it to produce 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.