DefaultBuilderProvider (MapStruct Processor 1.3.0.Beta1 API)

java.lang.Object
- org.mapstruct.ap.spi.DefaultBuilderProvider

All Implemented Interfaces:

BuilderProvider

Direct Known Subclasses:

ImmutablesBuilderProvider
```
public class DefaultBuilderProvider
extends Object
implements BuilderProvider
```
Default implementation of BuilderProvider. The default builder provider considers all public static parameterless methods of a TypeMirror as potential builder creation methods. For each potential builder creation method checks in the return type of the method if there exists a method that returns the initial TypeMirror if such a combination is found the BuilderInfo is created with those 2 methods. Example:
```
 public class Person {

     private final String firstName;
     private final String lastName;

     private Person(String firstName, String lastName) {
         this.firstName = firstName;
         this.lastName = lastName;
     }

     //getters

     public static Builder builder() {
         return new Builder();
     }

     public static class Builder {

         private String firstName;
         private String lastName;

         private Builder() {}

         //fluent setters

         public Person create() {
             return new Person( firstName, lastName );
         }
     }
 }
 
```
In the example above, when searching for a builder for the Person type. The Person#builder method would be a builder creation candidate. Then the return type of Person#builder, Builder, is investigated for a parameterless method that returns Person. When Builder#create is found the BuilderInfo is created with the Person#builder as a builder creation method and Builder#create as a build method.
IMPORTANT: Types from the java and javax packages are excluded from inspection
Author:

Filip Hrisafov

Constructor Summary

Constructors
Constructor and Description

DefaultBuilderProvider()

Constructors
Constructor and Description
`DefaultBuilderProvider()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected BuilderInfo`	`findBuilderInfo(TypeElement typeElement, Elements elements, Types types)` Find the `BuilderInfo` for the given `typeElement`.
`BuilderInfo`	`findBuilderInfo(TypeMirror type, Elements elements, Types types)` Find the builder information, if any, for the `type`.
`protected Collection<ExecutableElement>`	`findBuildMethods(TypeElement builderElement, TypeElement typeElement, Types types)` Searches for a build method for `typeElement` within the `builderElement`.
`protected TypeElement`	`getTypeElement(TypeMirror type)` Find the `TypeElement` for the given `TypeMirror`.
`protected boolean`	`isBuildMethod(ExecutableElement buildMethod, TypeElement typeElement, Types types)` Checks if the `buildMethod` is a method that creates `typeElement`.
`protected boolean`	`isPossibleBuilderCreationMethod(ExecutableElement method, TypeElement typeElement, Types types)` Checks if the `method` is a possible builder creation method.
`protected boolean`	`shouldIgnore(TypeElement typeElement)` Whether the `typeElement` should be ignored, i.e.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DefaultBuilderProvider
```
public DefaultBuilderProvider()
```
- Method Detail
  - findBuilderInfo
```
public BuilderInfo findBuilderInfo(TypeMirror type,
                                   Elements elements,
                                   Types types)
```
    Description copied from interface: BuilderProvider
    
    Find the builder information, if any, for the type.
    
    Specified by:
    
    findBuilderInfo in interface BuilderProvider
    
    Parameters:
    
    type - the type for which a builder should be found
    
    elements - the util elements that can be used for operations on program elements
    
    types - the util types that can be used for operations on TypeMirror(s)
    
    Returns:
    
    the builder info for the type if it exists, or null if there is no builder
  - getTypeElement
```
protected TypeElement getTypeElement(TypeMirror type)
```
    Find the TypeElement for the given TypeMirror.
    
    Parameters:
    
    type - for which the TypeElement needs to be found/
    
    Returns:
    
    the type element or null if the TypeMirror is not a DeclaredType and the declared type element is not TypeElement
    
    Throws:
    
    TypeHierarchyErroneousException - if the TypeMirror is of kind TypeKind.ERROR
  - findBuilderInfo
```
protected BuilderInfo findBuilderInfo(TypeElement typeElement,
                                      Elements elements,
                                      Types types)
```
    Find the BuilderInfo for the given typeElement.
    The default implementation iterates over all the methods in typeElement and uses isPossibleBuilderCreationMethod(ExecutableElement, TypeElement, Types) and findBuildMethods(TypeElement, TypeElement, Types) to create the BuilderInfo.
    The default implementation uses shouldIgnore(TypeElement) to check if the typeElement should be ignored.
    In case there are multiple BuilderInfo then a MoreThanOneBuilderCreationMethodException is thrown.
    
    Parameters:
    
    typeElement - the type element for which a builder searched
    
    elements - the util elements that can be used for operating on the type element
    
    types - the util types that can be used for operation on TypeMirror(s)
    
    Returns:
    
    the BuilderInfo or null if no builder was found for the type findBuildMethods(TypeElement, TypeElement, Types)
    
    Throws:
    
    MoreThanOneBuilderCreationMethodException - if there are multiple builder creation methods
  - isPossibleBuilderCreationMethod
```
protected boolean isPossibleBuilderCreationMethod(ExecutableElement method,
                                                  TypeElement typeElement,
                                                  Types types)
```
    Checks if the method is a possible builder creation method.
    The default implementation considers a method as a possible creation method if the following is satisfied:
    - The method has no parameters
    - It is a public static method
    - The return type of the method is not the same as the typeElement
    Parameters:
    
    method - The method that needs to be checked
    
    typeElement - the enclosing element of the method, i.e. the type in which the method is located in
    
    types - the util types that can be used for operations on TypeMirror(s)
    
    Returns:
    
    true if the method is a possible builder creation method, false otherwise
  - findBuildMethods
```
protected Collection<ExecutableElement> findBuildMethods(TypeElement builderElement,
                                                         TypeElement typeElement,
                                                         Types types)
```
    Searches for a build method for typeElement within the builderElement.
    The default implementation iterates over each method in builderElement and uses isBuildMethod(ExecutableElement, TypeElement, Types) to check if the method is a build method for typeElement.
    The default implementation uses shouldIgnore(TypeElement) to check if the builderElement should be ignored, i.e. not checked for build elements.
    If there are multiple methods that satisfy isBuildMethod(ExecutableElement, TypeElement, Types) and one of those methods is names build that that method would be considered as a build method.
    
    Parameters:
    
    builderElement - the element for the builder
    
    typeElement - the element for the type that is being built
    
    types - the util types tat can be used for operations on TypeMirror(s)
    
    Returns:
    
    the build method for the typeElement if it exists, or null if it does not build
  - isBuildMethod
```
protected boolean isBuildMethod(ExecutableElement buildMethod,
                                TypeElement typeElement,
                                Types types)
```
    Checks if the buildMethod is a method that creates typeElement.
    The default implementation considers a method to be a build method if the following is satisfied:
    - The method has no parameters
    - The method is public
    - The return type of method is assignable to the typeElement
    Parameters:
    
    buildMethod - the method that should be checked
    
    typeElement - the type element that needs to be built
    
    types - the util types that can be used for operations on TypeMirror(s)
    
    Returns:
    
    true if the buildMethod is a build method for typeElement, false otherwise
  - shouldIgnore
```
protected boolean shouldIgnore(TypeElement typeElement)
```
    Whether the typeElement should be ignored, i.e. not used in inspection.
    The default implementations ignores null elements and elements that belong to the java and javax packages
    
    Parameters:
    
    typeElement - that needs to be checked
    
    Returns:
    
    true if the element should be ignored, false otherwise

Class DefaultBuilderProvider

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultBuilderProvider

Method Detail

findBuilderInfo

getTypeElement

findBuilderInfo

isPossibleBuilderCreationMethod

findBuildMethods

isBuildMethod

shouldIgnore