private void handleEmbeddedType(Element element, Set<TypeElement> elements) {
TypeMirror type = element.asType();
if (element.getKind() == ElementKind.METHOD) {
type = ((ExecutableElement) element).getReturnType();
}
String typeName = type.toString();
if (typeName.startsWith(Collection.class.getName())
|| typeName.startsWith(List.class.getName())
|| typeName.startsWith(Set.class.getName())) {
type = ((DeclaredType) type).getTypeArguments().get(0);
} else if (typeName.startsWith(Map.class.getName())) {
type = ((DeclaredType) type).getTypeArguments().get(1);
}
TypeElement typeElement = typeExtractor.visit(type);
if (typeElement != null
&& !TypeUtils.hasAnnotationOfType(typeElement, conf.getEntityAnnotations())) {
if (!typeElement.getQualifiedName().toString().startsWith("java.")) {
elements.add(typeElement);
}
}
}
private void parseMethod(Api api, ExecutableElement executableElement) throws IOException {
Element actionElement =
generator
.getProcessingEnvironment()
.getElementUtils()
.getTypeElement(ApiMethodDoc.class.getName());
TypeMirror apiMethodDocType = actionElement.asType();
for (AnnotationMirror am : executableElement.getAnnotationMirrors()) {
if (am.getAnnotationType().equals(apiMethodDocType)) {
api.apiMethodDoc = Maps.newHashMap();
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> ee :
am.getElementValues().entrySet()) {
api.apiMethodDoc.put(ee.getKey().getSimpleName().toString(), ee.getValue());
}
break;
}
}
// generator.log("apiMethodDoc: " + api.apiMethodDoc);
if (null == api.apiMethodDoc) {
generator.log("Method miss @ApiMethodDoc. " + executableElement);
return;
}
api.methodName = executableElement.getSimpleName().toString();
api.methodMapping = executableElement.getAnnotation(RequestMapping.class);
api.parameters = Lists.newArrayList();
for (VariableElement var : executableElement.getParameters()) {
api.parameters.add(var);
}
}
private boolean doesClassContainNoArgsConstructor(Element el) {
for (Element subelement : el.getEnclosedElements()) {
if (subelement.getKind() == ElementKind.CONSTRUCTOR
&& subelement.getModifiers().contains(Modifier.PUBLIC)) {
TypeMirror mirror = subelement.asType();
if (mirror.accept(noArgsVisitor, null)) return true;
}
}
return false;
}
private Set<TypeElement> processDelegateMethods() {
Set<Element> delegateMethods = (Set) getElements(QueryDelegate.class);
Set<TypeElement> typeElements = new HashSet<TypeElement>();
for (Element delegateMethod : delegateMethods) {
ExecutableElement method = (ExecutableElement) delegateMethod;
Element element = delegateMethod.getEnclosingElement();
String name = method.getSimpleName().toString();
Type delegateType = typeFactory.getType(element.asType(), true);
Type returnType = typeFactory.getType(method.getReturnType(), true);
List<Parameter> parameters = elementHandler.transformParams(method.getParameters());
// remove first element
parameters = parameters.subList(1, parameters.size());
EntityType entityType = null;
for (AnnotationMirror annotation : delegateMethod.getAnnotationMirrors()) {
if (TypeUtils.isAnnotationMirrorOfType(annotation, QueryDelegate.class)) {
TypeMirror type = TypeUtils.getAnnotationValueAsTypeMirror(annotation, "value");
if (type != null) {
entityType = typeFactory.getEntityType(type, true);
}
}
}
if (entityType != null) {
registerTypeElement(entityType.getFullName(), (TypeElement) element);
entityType.addDelegate(
new Delegate(entityType, delegateType, name, parameters, returnType));
TypeElement typeElement =
processingEnv.getElementUtils().getTypeElement(entityType.getFullName());
boolean isAnnotated = false;
for (Class<? extends Annotation> ann : conf.getEntityAnnotations()) {
if (typeElement.getAnnotation(ann) != null) {
isAnnotated = true;
}
}
if (isAnnotated) {
// handle also properties of entity type
typeElements.add(
processingEnv.getElementUtils().getTypeElement(entityType.getFullName()));
} else {
// skip handling properties
context.extensionTypes.put(entityType.getFullName(), entityType);
context.allTypes.put(entityType.getFullName(), entityType);
}
}
}
return typeElements;
}
private void processAnnotations() {
processExclusions();
Set<TypeElement> elements = collectElements();
// create meta models
for (Element element : elements) {
typeFactory.getEntityType(element.asType(), false);
}
for (Element element : elements) {
typeFactory.getEntityType(element.asType(), true);
}
// add properties
boolean embeddableAnn = conf.getEmbeddableAnnotation() != null;
boolean altEntityAnn = conf.getAlternativeEntityAnnotation() != null;
boolean superAnn = conf.getSuperTypeAnnotation() != null;
for (TypeElement element : elements) {
EntityType entityType = elementHandler.handleEntityType(element);
registerTypeElement(entityType.getFullName(), element);
if (element.getAnnotation(conf.getEntityAnnotation()) != null) {
context.entityTypes.put(entityType.getFullName(), entityType);
} else if (altEntityAnn
&& element.getAnnotation(conf.getAlternativeEntityAnnotation()) != null) {
context.entityTypes.put(entityType.getFullName(), entityType);
} else if (embeddableAnn && element.getAnnotation(conf.getEmbeddableAnnotation()) != null) {
context.embeddableTypes.put(entityType.getFullName(), entityType);
} else if (superAnn && element.getAnnotation(conf.getSuperTypeAnnotation()) != null) {
context.supertypes.put(entityType.getFullName(), entityType);
} else if (!entityType.getDelegates().isEmpty()) {
context.extensionTypes.put(entityType.getFullName(), entityType);
} else {
context.embeddableTypes.put(entityType.getFullName(), entityType);
}
context.allTypes.put(entityType.getFullName(), entityType);
}
// track also methods from external entity types
for (EntityType entityType : new ArrayList<EntityType>(typeFactory.getEntityTypes())) {
String fullName = entityType.getFullName();
if (!context.allTypes.keySet().contains(fullName)) {
// System.err.println(fullName);
TypeElement element = processingEnv.getElementUtils().getTypeElement(fullName);
if (element != null) {
elementHandler.handleEntityType(element);
}
}
}
// add external parents
for (Element element : elements) {
EntityType entityType = typeFactory.getEntityType(element.asType(), false);
addExternalParents(entityType);
}
// add properties from parents
Set<EntityType> handled = new HashSet<EntityType>();
for (EntityType entityType : context.allTypes.values()) {
addSupertypeFields(entityType, handled);
}
processProjectionTypes(elements);
// extend entity types
typeFactory.extendTypes();
context.clean();
}
/**
* Whether the specified declaration is throwable.
*
* @param declaration The declaration to determine whether it is throwable.
* @return Whether the specified declaration is throwable.
*/
protected boolean isThrowable(Element declaration) {
return declaration.getKind() == ElementKind.CLASS
&& ((DecoratedTypeMirror) declaration.asType()).isInstanceOf(Throwable.class);
}