Returns the abstract build method. If the @AutoValue class is Foo, this is an abstract no-argument method in the builder class that returns Foo. This might be called build(), or, following a common convention, it might be called autoBuild() and used in the implementation of a build() method that is defined in the builder class.

Extensions should call the build() method in preference to this one. But they should override this one if they want to customize build-time behaviour.

Returns static no-argument methods in the @AutoValue class that return the builder type.

Consider a class like this:

  @AutoValue abstract class Foo {
    abstract String bar();

    static Builder builder() {
      return new AutoValue_Foo.Builder()
          .setBar("default bar");
    }

    @AutoValue.Builder
    abstract class Builder {
      abstract Builder setBar(String x);
      abstract Foo build();
    }
  }

Here builderMethods() will return a set containing the method Foo.builder(). Generated code should usually call this method in preference to constructing AutoValue_Foo.Builder() directly, because this method can establish default values for properties, as it does here.

Returns the @AutoValue.Builder interface or abstract class that this object represents.

Returns the method build() in the builder class, if it exists and returns the @AutoValue type. This is the method that generated code for @AutoValue class Foo should call in order to get an instance of Foo from its builder. The returned method is called build(); if the builder uses some other name then extensions have no good way to guess how they should build.

A common convention is for build() to be a concrete method in the @AutoValue.Builder class, which calls an abstract method autoBuild() that is implemented in the generated subclass. The build() method can then do validation, defaulting, and so on.

Returns a map from property names to property builders. For example, if there is a property foo defined by abstract ImmutableList<String> foo(); or abstract ImmutableList<String> getFoo(); in the @AutoValue class, then there can potentially be a builder defined by abstract ImmutableList.Builder<String> fooBuilder(); in the @AutoValue.Builder class. This map would then map "foo" to the ExecutableElement representing fooBuilder().

Returns a map from property names to the corresponding setters. A property may have more than one setter. For example, an ImmutableList<String> might be set by setFoo(ImmutableList<String>) and setFoo(String[]).

Returns abstract no-argument methods in the @AutoValue class that return the builder type.

Consider a class like this:

  @AutoValue abstract class Foo {
    abstract String bar();

    abstract Builder toBuilder();

    ...
    @AutoValue.Builder
    abstract static class Builder {...}
  }

Here toBuilderMethods() will return a set containing the method Foo.toBuilder().

Returns the complete set of abstract methods defined in or inherited by the @AutoValue class. This includes all methods that define properties (like abstract String getBar()), any abstract toBuilder() method, and any other abstract method even if it has been consumed by this or another Extension.

Returns the annotated class that this generation cycle is based on.

Given @AutoValue public class Foo {...}, this will be Foo.

Returns a representation of the Builder associated with the @AutoValue class, if there is one.

This method returns Optional#empty() if called from within the applicable method. If an Extension needs Builder information to decide whether it is applicable, it should return true from the applicable method and then return null from the generateClass method if it does not need to generate a class after all.

The default implementation of this method returns Optional#empty() for compatibility with extensions which may have implemented this interface themselves.

Returns the complete list of annotations defined on the classToCopyFrom that should be added to any generated subclass. Only annotations visible to the @AutoValue will be present. See AutoValue.CopyAnnotations for more information.

The default implementation of this method returns an empty list for compatibility with extensions which may have implemented this interface themselves.

The fully-qualified name of the last class in the AutoValue hierarchy. For an @AutoValue class foo.bar.Baz, this will be foo.bar.AutoValue_Baz. The class may be generated by an extension, which will be the current extension if the isFinal parameter to AutoValueExtension#generateClass is true and the returned string is not null.

For compatibility reasons, this method has a default implementation that throws an exception. The AutoValue processor supplies an implementation that behaves as documented.

Returns the complete list of annotations defined on the method that should be applied to any override of that method. Only annotations visible to the @AutoValue will be present. See AutoValue.CopyAnnotations for more information.

The default implementation of this method returns an empty list for compatibility with extensions which may have implemented this interface themselves.

Returns the package name of the classes to be generated.

Returns the processing environment of this generation cycle. This can be used, among other things, to produce compilation warnings or errors, using ProcessingEnvironment#getMessager().

Returns the ordered collection of properties to be generated by AutoValue. Each key is a property name, and the corresponding value is the getter method for that property. For example, if property bar is defined by abstract String getBar() then this map will have an entry mapping "bar" to the ExecutableElement for getBar().

To determine the type of a property, it is best to use propertyTypes() rather than looking at the return type of the ExecutableElement in this map. The reason is that the final type of the property might be different because of type variables. For example, if you have...

  interface Parent<T> {
    T bar();
  }
 @AutoValue abstract class Foo implements Parent<String> {...}

Returns the properties to be generated by AutoValue, with their types. Each key is a property name, and the corresponding value is the type of that property. The order of the map entries is the same as the order of the @AutoValue properties.

For example, if property bar is defined by abstract String getBar() then this map will have an entry mapping "bar" to the TypeMirror for String.

For compatibility reasons, this method has a default implementation that throws an exception. The AutoValue processor supplies an implementation that behaves as documented.

This extension is aggregating, meaning that it may generate outputs based on several annotated input classes and it respects the constraints imposed on aggregating processors. It is unusual for AutoValue extensions to be aggregating.

See Also

Gradle definition of aggregating processors

This extension is isolating, meaning roughly that its output depends on the @AutoValue class and its dependencies, but not on other @AutoValue classes that might be compiled at the same time. The constraints that an isolating extension must respect are the same as those that Gradle imposes on an isolating annotation processor.

See Also

Gradle definition of isolating processors

The incrementality of this extension is unknown, or it is neither aggregating nor isolating.