com.fortyoneconcepts.valjogen.processor.builders

Class ModelBuilder

java.lang.Object

com.fortyoneconcepts.valjogen.processor.builders.ModelBuilder

public final class ModelBuilder
extends Object

This class is responsible for transforming data in the javax.lang.model.* format to our own valjogen models. The javax.lang.model.* lacks detailed documentation so some points is included here: - Elements are about the static structure of the program, ie packages, classes, methods and variables (similar to what is seen in a package explorer in an IDE). - Types are about the statically defined type constraints of the program, i.e. types, generic type parameters, generic type wildcards (Everything that is part of Java's type declarations before type erasure). - Mirror objects is where you can see the reflection of the object, thus seperating queries from the internal structure. This allows reflectiong on stuff that has not been loaded. Nb: Instances of this class is not multi-thread safe. Create a new for each thread. Note that we build our class gradually, so be careful when calling method on class objects while they are constructed. Simple method are generally safe, while methods that depend on structure initialization should not be called unless the class is fully initialized.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	ModelBuilder.ExecutableElementInfo Executable elements (methods) along with their declared mirror types etc.
private class	ModelBuilder.StatusHolder Contains various data that streams need to manipulate and this needs to be accessed by reference.

Field Summary

Fields

Modifier and Type	Field and Description
private static String	comparableClass
private static String	compareToOverloadName
private Configuration	configuration
private Elements	elements
private DiagnosticMessageConsumer	errorConsumer
private static String	externalizableClass
private static Logger	LOGGER
private TypeElement	masterInterfaceElement
private NoType	noType
private ResourceLoader	resourceLoader
private static String	serializbleClass
private static HashMap<String,Predicate4<Configuration,Clazz,List<Method>,List<Member>>>	templateMethodConditions Controls when corresponding available ST template methods should be called.
private STTemplates	templates
private TypeBuilder	typeBuilder
private Types	types

Constructor Summary

Constructors

Constructor and Description
ModelBuilder(Types types, Elements elements, DiagnosticMessageConsumer errorConsumer, TypeElement masterInterfaceElement, Configuration configuration, ResourceLoader resourceLoader, STTemplates templates) Create an instance of this builder that can build the specified class and all dependencies.

Method Summary

Modifier and Type	Method and Description
Clazz	buildNewCLazz() Create a Clazz model instance representing a class to be generated along with all its dependent model instances by inspecting javax.lang.model metadata and the configuration provided by annotation(s) read by annotation processor.
private void	claimAndVerifyMethods(List<Method> nonPropertyMethods, List<Property> propertyMethods, Set<String> applicableTemplateImplementedMethodNames)
private List<Annotation>	createConstructorAnnotations(Clazz clazz, List<Parameter> parameters, boolean primaryConstructor, boolean includeFactoryMethod)
private EnumSet<Modifier>	createConstructorModifiers(EnumSet<Modifier> classModifiers, List<Parameter> parameters, boolean includeFactoryMethod, boolean mustHaveDefaultPublicCtr)
private List<Annotation>	createConstructorParameterAnnotations(Clazz clazz, boolean primaryConstructor, String parameterName, boolean includeFactoryMethod)
private List<Method>	createConstructorsAndFactoryMethods(Clazz clazz, ObjectType baseClazzType, List<Member> members, EnumSet<Modifier> classModifiers, String[] baseClazzConstructors)
private List<List<Parameter>>	createConstuctorsParameterLists(Clazz clazz, List<Member> members, boolean primary, boolean includeFactoryMethod)
private List<Annotation>	createFactoryMethodAnnotations(Clazz clazz, List<Parameter> parameters, boolean primaryFactoryMethod)
private List<Annotation>	createFactoryMethodParameterAnnotations(Clazz clazz, boolean primaryFactoryMethod, String parameterName)
private List<List<Parameter>>	createFactoryMethodsParameterLists(Clazz clazz, List<Member> members, boolean primary)
private List<Type>	createImportTypes(BasicClazz clazz, DeclaredType baseClazzDeclaredType, List<DeclaredType> implementedDecalredInterfaceTypes)
private List<Method>	createMagicSerializationMethods(BasicClazz clazz)
private List<Annotation>	createMemberAnnotations(BasicClazz clazz, String memberName)
private Method	createMethod(BasicClazz clazz, Map<String,Member> membersByName, ModelBuilder.StatusHolder statusHolder, ExecutableElement m, ExecutableElement mOverriddenBy, DeclaredType interfaceOrClassMirrorType)
private List<Annotation>	createMethodAnnotations(BasicClazz clazz, String methodName, List<Parameter> parameters, EnumSet<Modifier> modifiers)
private Member	createPropertyMemberIfValidProperty(BasicClazz clazz, DeclaredType interfaceOrClassMirrorType, TypeMirror returnTypeMirror, List<? extends VariableElement> setterParams, List<? extends TypeMirror> setterParamTypes, ExecutableElement methodElement, PropertyKind kind)
private String	createQualifiedClassName(String qualifedInterfaceName, String sourcePackageName)
private Property	createValidatedProperty(BasicClazz clazz, ModelBuilder.StatusHolder statusHolder, Type declaringType, ExecutableElement m, Type returnType, List<Parameter> parameters, List<Type> thrownTypes, String javaDoc, PropertyKind propertyKind, Member propertyMember, EnumSet<Modifier> modifiers, ImplementationInfo implementationInfo)
private List<Type>	filterImportTypes(BasicClazz clazz, List<Type> importTypes)
private List<Member>	getSelectedComparableMembers(Map<String,Member> membersByName, Map<String,Member> baseMembersByName, Method comparableMethodToImplement)
private static boolean	instanceImplementationExists(Clazz clazz, String methodName, List<Method> methods)
private static boolean	mustImplementComparable(Clazz clazz, List<Method> methods)
private String	syntesisePropertyMemberName(String[] propertyPrefixes, ExecutableElement method)
private Stream<ModelBuilder.ExecutableElementInfo>	toExecutableElementAndDeclaredTypePair(DeclaredType interfaceOrClasMirrorType, Stream<ExecutableElement> elements)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOGGER

private static final Logger LOGGER

comparableClass

private static final String comparableClass

serializbleClass

private static final String serializbleClass

externalizableClass

private static final String externalizableClass

compareToOverloadName

private static final String compareToOverloadName

See Also:

Constant Field Values

templateMethodConditions

private static final HashMap<String,Predicate4<Configuration,Clazz,List<Method>,List<Member>>> templateMethodConditions

Controls when corresponding available ST template methods should be called.

typeBuilder

private final TypeBuilder typeBuilder

types

private final Types types

elements

private final Elements elements

errorConsumer

private final DiagnosticMessageConsumer errorConsumer

masterInterfaceElement

private final TypeElement masterInterfaceElement

configuration

private final Configuration configuration

resourceLoader

private final ResourceLoader resourceLoader

templates

private final STTemplates templates

noType

private final NoType noType

Constructor Detail

ModelBuilder

public ModelBuilder(Types types,
                    Elements elements,
                    DiagnosticMessageConsumer errorConsumer,
                    TypeElement masterInterfaceElement,
                    Configuration configuration,
                    ResourceLoader resourceLoader,
                    STTemplates templates)

Create an instance of this builder that can build the specified class and all dependencies.

Parameters:

types - Types helper from javax.lang.model

elements - Elements helper from jacax.lang.model

errorConsumer - Where to send errors.

masterInterfaceElement - The interface that has been selected for code generation (by an annotation).

configuration - Descripes the user-selected details about what should be generated (combination of annotation(s) and annotation processor setup).

resourceLoader - What to call to get resource files

templates - StringTemplate templates holder used to reflect on what methods are supplied.

Method Detail

buildNewCLazz

public Clazz buildNewCLazz()
                    throws Exception

Create a Clazz model instance representing a class to be generated along with all its dependent model instances by inspecting javax.lang.model metadata and the configuration provided by annotation(s) read by annotation processor.

Returns:

A initialized Clazz which is a model for what our generated code should look like.

Throws:

Exception - if a fatal error has occured.

claimAndVerifyMethods

private void claimAndVerifyMethods(List<Method> nonPropertyMethods,
                                   List<Property> propertyMethods,
                                   Set<String> applicableTemplateImplementedMethodNames)

createConstructorsAndFactoryMethods

private List<Method> createConstructorsAndFactoryMethods(Clazz clazz,
                                                         ObjectType baseClazzType,
                                                         List<Member> members,
                                                         EnumSet<Modifier> classModifiers,
                                                         String[] baseClazzConstructors)

createConstructorModifiers

private EnumSet<Modifier> createConstructorModifiers(EnumSet<Modifier> classModifiers,
                                                     List<Parameter> parameters,
                                                     boolean includeFactoryMethod,
                                                     boolean mustHaveDefaultPublicCtr)

createConstuctorsParameterLists

private List<List<Parameter>> createConstuctorsParameterLists(Clazz clazz,
                                                              List<Member> members,
                                                              boolean primary,
                                                              boolean includeFactoryMethod)

createFactoryMethodsParameterLists

private List<List<Parameter>> createFactoryMethodsParameterLists(Clazz clazz,
                                                                 List<Member> members,
                                                                 boolean primary)

createConstructorAnnotations

private List<Annotation> createConstructorAnnotations(Clazz clazz,
                                                      List<Parameter> parameters,
                                                      boolean primaryConstructor,
                                                      boolean includeFactoryMethod)

createFactoryMethodAnnotations

private List<Annotation> createFactoryMethodAnnotations(Clazz clazz,
                                                        List<Parameter> parameters,
                                                        boolean primaryFactoryMethod)

createConstructorParameterAnnotations

private List<Annotation> createConstructorParameterAnnotations(Clazz clazz,
                                                               boolean primaryConstructor,
                                                               String parameterName,
                                                               boolean includeFactoryMethod)

createFactoryMethodParameterAnnotations

private List<Annotation> createFactoryMethodParameterAnnotations(Clazz clazz,
                                                                 boolean primaryFactoryMethod,
                                                                 String parameterName)

createMagicSerializationMethods

private List<Method> createMagicSerializationMethods(BasicClazz clazz)

getSelectedComparableMembers

private List<Member> getSelectedComparableMembers(Map<String,Member> membersByName,
                                                  Map<String,Member> baseMembersByName,
                                                  Method comparableMethodToImplement)

toExecutableElementAndDeclaredTypePair

private Stream<ModelBuilder.ExecutableElementInfo> toExecutableElementAndDeclaredTypePair(DeclaredType interfaceOrClasMirrorType,
                                                                                          Stream<ExecutableElement> elements)

createMethod

private Method createMethod(BasicClazz clazz,
                            Map<String,Member> membersByName,
                            ModelBuilder.StatusHolder statusHolder,
                            ExecutableElement m,
                            ExecutableElement mOverriddenBy,
                            DeclaredType interfaceOrClassMirrorType)

createMethodAnnotations

private List<Annotation> createMethodAnnotations(BasicClazz clazz,
                                                 String methodName,
                                                 List<Parameter> parameters,
                                                 EnumSet<Modifier> modifiers)

createImportTypes

private List<Type> createImportTypes(BasicClazz clazz,
                                     DeclaredType baseClazzDeclaredType,
                                     List<DeclaredType> implementedDecalredInterfaceTypes)

createValidatedProperty

private Property createValidatedProperty(BasicClazz clazz,
                                         ModelBuilder.StatusHolder statusHolder,
                                         Type declaringType,
                                         ExecutableElement m,
                                         Type returnType,
                                         List<Parameter> parameters,
                                         List<Type> thrownTypes,
                                         String javaDoc,
                                         PropertyKind propertyKind,
                                         Member propertyMember,
                                         EnumSet<Modifier> modifiers,
                                         ImplementationInfo implementationInfo)

filterImportTypes

private List<Type> filterImportTypes(BasicClazz clazz,
                                     List<Type> importTypes)

createQualifiedClassName

private String createQualifiedClassName(String qualifedInterfaceName,
                                        String sourcePackageName)

createPropertyMemberIfValidProperty

private Member createPropertyMemberIfValidProperty(BasicClazz clazz,
                                                   DeclaredType interfaceOrClassMirrorType,
                                                   TypeMirror returnTypeMirror,
                                                   List<? extends VariableElement> setterParams,
                                                   List<? extends TypeMirror> setterParamTypes,
                                                   ExecutableElement methodElement,
                                                   PropertyKind kind)

createMemberAnnotations

private List<Annotation> createMemberAnnotations(BasicClazz clazz,
                                                 String memberName)

syntesisePropertyMemberName

private String syntesisePropertyMemberName(String[] propertyPrefixes,
                                           ExecutableElement method)

mustImplementComparable

private static boolean mustImplementComparable(Clazz clazz,
                                               List<Method> methods)

instanceImplementationExists

private static boolean instanceImplementationExists(Clazz clazz,
                                                    String methodName,
                                                    List<Method> methods)