pack-priv abstract Class BuilderMethodClassifier<E extends javax.lang.model.element.Element>

Classifies a method and update the state of this object based on what is found.

Classifies a method given that it has no arguments. Currently a method with no arguments can be a build() method, meaning that its return type must be the @AutoValue class; it can be a getter, with the same signature as one of the property getters in the @AutoValue class; or it can be a property builder, like ImmutableList.Builder<String> foosBuilder() for the property defined by ImmutableList<String> foos() or getFoos().

Classifies a method given that it has one argument. A method with one argument can be:

• a setter, meaning that it looks like foo(T) or setFoo(T), where the AutoValue class has a property called foo of type T;
• a property builder with one argument, meaning it looks like ImmutableSortedSet.Builder<V> foosBuilder(Comparator<V>), where the AutoValue class has a property called foos with a type whose builder can be made with an argument of the given type.

Classifies a method given that it has one argument and is a property builder with a parameter, like ImmutableSortedSet.Builder<String> foosBuilder(Comparator<String>).

Parameters

method:javax.lang.model.element.ExecutableElement

A method to classify

Returns:boolean

true if method has been classified successfully

Returns copyOf methods from the given type. These are static methods with a single parameter, called copyOf or copyOfSorted for Guava collection types, and called of or ofNullable for Optional. All of Guava's concrete immutable collection types have at least one such method, but we will also accept other classes with an appropriate copyOf method, such as java.util.EnumSet.

Returns an Optional describing how to convert a value from the setter's parameter type to the getter's return type using one of the given methods, or Optional.empty() if the conversion isn't possible. An error will have been reported in the latter case.

Returns an Optional containing a function to use copyOfMethod to copy the parameterType to the targetType, or Optional.empty() if the method can't be used. For example, we might have a property of type ImmutableSet<T> and our setter has a parameter of type Set<? extends T>. Can we use ImmutableSet<E> ImmutableSet.copyOf(Collection<? extends E>) to set the property? What about ImmutableSet<E> ImmutableSet.copyOf(E[])?

The example here is deliberately complicated, in that it has a type parameter of its own, presumably because the @AutoValue class is Foo<T>. One subtle point is that the builder will then be Builder<T> where this T is a different type variable. However, we've used TypeVariables to ensure that the T in ImmutableSet<T> is actually the one from Builder<T> instead of the original one from Foo<T>.}

Parameters

copyOfMethod:javax.lang.model.element.ExecutableElement

the candidate method to do the copy, ImmutableSet.copyOf(Collection<? extends E>) or ImmutableSet.copyOf(E[]) in the examples.

targetType:javax.lang.model.type.DeclaredType

the type of the property to be set, ImmutableSet<T> in the example.

parameterType:javax.lang.model.type.TypeMirror

the type of the setter parameter, Set<? extends T> in the example.

Returns:Optional<BuilderSpec.Copier>

a function that maps a string parameter to a method call using that parameter. For example it might map foo to ImmutableList.copyOf(foo).

Returns an Optional describing how to convert a value from the setter's parameter type to the getter's return type, or Optional.empty() if the conversion isn't possible. An error will have been reported in the latter case. We can convert if they are already the same type, when the returned function will be the identity; or if the setter type can be copied using a method like ImmutableList.copyOf or Optional.of, when the returned function will be something like s -> "Optional.of(" + s + ")".

True if the given property is nullable, either because its type has a @Nullable type annotation, or because its getter method has a @Nullable method annotation.