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);
}
}
/**
* Returns the annotation on {@code element} formatted as a Map. This returns a Map rather than an
* instance of the annotation interface to work-around the fact that Class and Class[] fields
* won't work at code generation time. See
* http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5089128
*/
public static Map<String, Object> getAnnotation(Class<?> annotationType, Element element) {
for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
if (!rawTypeToString(annotation.getAnnotationType(), '$').equals(annotationType.getName())) {
continue;
}
Map<String, Object> result = new LinkedHashMap<String, Object>();
for (Method m : annotationType.getMethods()) {
result.put(m.getName(), m.getDefaultValue());
}
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e :
annotation.getElementValues().entrySet()) {
String name = e.getKey().getSimpleName().toString();
Object value = e.getValue().accept(VALUE_EXTRACTOR, null);
Object defaultValue = result.get(name);
if (!lenientIsInstance(defaultValue.getClass(), value)) {
throw new IllegalStateException(
String.format(
"Value of %s.%s is a %s but expected a %s\n value: %s",
annotationType,
name,
value.getClass().getName(),
defaultValue.getClass().getName(),
value instanceof Object[] ? Arrays.toString((Object[]) value) : value));
}
result.put(name, value);
}
return result;
}
return null; // Annotation not found.
}
private Set<ConstraintCheckError> checkInternal(
Element element, AnnotationMirror annotation, TypeMirror type, String messageKey) {
if (constraintHelper.checkConstraint(annotation.getAnnotationType(), type)
!= ConstraintCheckResult.ALLOWED) {
return CollectionHelper.asSet(
new ConstraintCheckError(
element,
annotation,
messageKey,
annotation.getAnnotationType().asElement().getSimpleName()));
}
return Collections.emptySet();
}
@Override
public Set<TypeElement> scan(Element e, Set<TypeElement> p) {
for (AnnotationMirror annotationMirror : elements.getAllAnnotationMirrors(e)) {
Element e2 = annotationMirror.getAnnotationType().asElement();
p.add((TypeElement) e2);
}
return super.scan(e, p);
}
private static boolean hasAnnotationWithName(Element element, String simpleName) {
for (AnnotationMirror mirror : element.getAnnotationMirrors()) {
String annotationName = mirror.getAnnotationType().asElement().getSimpleName().toString();
if (simpleName.equals(annotationName)) {
return true;
}
}
return false;
}
/**
* Determines the least upper bound of a1 and a2. If a1 and a2 are both the same type of Value
* annotation, then the LUB is the result of taking all values from both a1 and a2 and removing
* duplicates. If a1 and a2 are not the same type of Value annotation they may still be
* mergeable because some values can be implicitly cast as others. If a1 and a2 are both in
* {DoubleVal, IntVal} then they will be converted upwards: IntVal → DoubleVal to arrive at
* a common annotation type.
*
* @return the least upper bound of a1 and a2
*/
@Override
public AnnotationMirror leastUpperBound(AnnotationMirror a1, AnnotationMirror a2) {
if (!AnnotationUtils.areSameIgnoringValues(getTopAnnotation(a1), getTopAnnotation(a2))) {
return null;
} else if (isSubtype(a1, a2)) {
return a2;
} else if (isSubtype(a2, a1)) {
return a1;
}
// If both are the same type, determine the type and merge:
else if (AnnotationUtils.areSameIgnoringValues(a1, a2)) {
List<Object> a1Values =
AnnotationUtils.getElementValueArray(a1, "value", Object.class, true);
List<Object> a2Values =
AnnotationUtils.getElementValueArray(a2, "value", Object.class, true);
HashSet<Object> newValues = new HashSet<Object>(a1Values.size() + a2Values.size());
newValues.addAll(a1Values);
newValues.addAll(a2Values);
return createAnnotation(a1.getAnnotationType().toString(), newValues);
}
// Annotations are in this hierarchy, but they are not the same
else {
// If either is UNKNOWNVAL, ARRAYLEN, STRINGVAL, or BOOLEAN then
// the LUB is
// UnknownVal
if (!(AnnotationUtils.areSameByClass(a1, IntVal.class)
|| AnnotationUtils.areSameByClass(a1, DoubleVal.class)
|| AnnotationUtils.areSameByClass(a2, IntVal.class)
|| AnnotationUtils.areSameByClass(a2, DoubleVal.class))) {
return UNKNOWNVAL;
} else {
// At this point one of them must be a DoubleVal and one an
// IntVal
AnnotationMirror doubleAnno;
AnnotationMirror intAnno;
if (AnnotationUtils.areSameByClass(a2, DoubleVal.class)) {
doubleAnno = a2;
intAnno = a1;
} else {
doubleAnno = a1;
intAnno = a2;
}
List<Long> intVals = getIntValues(intAnno);
List<Double> doubleVals = getDoubleValues(doubleAnno);
for (Long n : intVals) {
doubleVals.add(n.doubleValue());
}
return createDoubleValAnnotation(doubleVals);
}
}
}
private AnnotationMirror getAnnotation(Element element, String type) {
if (element != null) {
for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
if (type.equals(annotation.getAnnotationType().toString())) {
return annotation;
}
}
}
return null;
}
private Optional<String> getPointsAnnotationValueIfAny(Element element) {
for (AnnotationMirror am : element.getAnnotationMirrors()) {
Name annotationName = am.getAnnotationType().asElement().getSimpleName();
if (annotationName.contentEquals("Points")) {
String value = getAnnotationValue(am);
return Optional.of(value);
}
}
return Optional.absent();
}
static boolean isJacksonSerializedAnnotated(Element element) {
List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
for (AnnotationMirror annotation : annotationMirrors) {
TypeElement annotationElement = (TypeElement) annotation.getAnnotationType().asElement();
if (JACKSON_MAPPING_ANNOTATION_CLASSES.contains(
annotationElement.getQualifiedName().toString())) {
return true;
}
}
return false;
}
static boolean isJacksonJsonTypeInfoAnnotated(Element element) {
List<? extends AnnotationMirror> annotationMirrors = element.getAnnotationMirrors();
for (AnnotationMirror annotation : annotationMirrors) {
TypeElement annotationElement = (TypeElement) annotation.getAnnotationType().asElement();
if ("com.fasterxml.jackson.annotation.JsonTypeInfo"
.equals(annotationElement.getQualifiedName().toString())) {
return true;
}
}
return false;
}
GwtCompatibility(TypeElement type) {
Optional<AnnotationMirror> gwtCompatibleAnnotation = Optional.absent();
List<? extends AnnotationMirror> annotations = type.getAnnotationMirrors();
for (AnnotationMirror annotation : annotations) {
Name name = annotation.getAnnotationType().asElement().getSimpleName();
if (name.contentEquals("GwtCompatible")) {
gwtCompatibleAnnotation = Optional.of(annotation);
}
}
this.gwtCompatibleAnnotation = gwtCompatibleAnnotation;
}
/**
* Returns an {@link AnnotationMirror} for the annotation of type {@code annotationClassName} on
* {@code element}, or {@link Optional#absent()} if no such annotation exists.
*/
public static Optional<AnnotationMirror> findAnnotationMirror(
Element element, String annotationClassName) {
for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
TypeElement annotationTypeElement =
(TypeElement) (annotationMirror.getAnnotationType().asElement());
if (annotationTypeElement.getQualifiedName().contentEquals(annotationClassName)) {
return Optional.of(annotationMirror);
}
}
return Optional.absent();
}
static Parameter forVariableElement(VariableElement variable) {
ImmutableSet.Builder<String> qualifiers = ImmutableSet.builder();
for (AnnotationMirror annotationMirror : variable.getAnnotationMirrors()) {
DeclaredType annotationType = annotationMirror.getAnnotationType();
if (annotationType.asElement().getAnnotation(Qualifier.class) != null) {
qualifiers.add(Mirrors.getQualifiedName(annotationType).toString());
}
}
return new Parameter(
FluentIterable.from(qualifiers.build()).first(),
variable.asType().toString(),
variable.getSimpleName().toString());
}
protected boolean isExplicitTypeDefinition(Element declaration) {
if (declaration.getKind() != ElementKind.CLASS) {
debug("%s isn't a potential JAXB type because it's not a class.", declaration);
return false;
}
PackageElement pckg =
this.context.getProcessingEnvironment().getElementUtils().getPackageOf(declaration);
if ((pckg != null) && (pckg.getAnnotation(Ignore.class) != null)) {
debug(
"%s isn't a potential JAXB type because its package is annotated as to be ignored.",
declaration);
return false;
}
if (isThrowable(declaration)) {
debug(
"%s isn't a potential JAXB type because it's an instance of java.lang.Throwable.",
declaration);
return false;
}
List<? extends AnnotationMirror> annotationMirrors = declaration.getAnnotationMirrors();
boolean explicitXMLTypeOrElement = false;
for (AnnotationMirror mirror : annotationMirrors) {
Element annotationDeclaration = mirror.getAnnotationType().asElement();
if (annotationDeclaration != null) {
String fqn =
annotationDeclaration instanceof TypeElement
? ((TypeElement) annotationDeclaration).getQualifiedName().toString()
: "";
// exclude all XmlTransient types and all jaxws types.
if (XmlTransient.class.getName().equals(fqn)
|| fqn.startsWith("javax.xml.ws")
|| fqn.startsWith("javax.ws.rs")
|| fqn.startsWith("javax.jws")) {
debug("%s isn't a potential JAXB type because of annotation %s.", declaration, fqn);
return false;
} else {
explicitXMLTypeOrElement =
(XmlType.class.getName().equals(fqn)) || (XmlRootElement.class.getName().equals(fqn));
}
}
if (explicitXMLTypeOrElement) {
break;
}
}
return explicitXMLTypeOrElement;
}
public static MetaAnnotated from(AnnotationMirror mirror) {
TypeElement element = (TypeElement) mirror.getAnnotationType().asElement();
String name = element.getQualifiedName().toString();
@Nullable MetaAnnotated metaAnnotated = cache.get(element);
if (metaAnnotated == null) {
metaAnnotated = ImmutableProto.MetaAnnotated.of(element);
@Nullable MetaAnnotated existing = cache.putIfAbsent(name, metaAnnotated);
if (existing != null) {
metaAnnotated = existing;
}
}
return metaAnnotated;
}
private static String wrapText(Element element, AnnotationMirror mirror, String text) {
StringBuilder b = new StringBuilder();
if (element != null) {
b.append("Element " + element.toString());
}
if (mirror != null) {
b.append(" at annotation @" + Utils.getSimpleName(mirror.getAnnotationType()));
}
if (b.length() > 0) {
b.append(" is erroneous: ").append(text);
return b.toString();
} else {
return text;
}
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
for (TypeElement te : ElementFilter.typesIn(roundEnv.getRootElements())) {
if (isSimpleName(te, "InvalidSource")) {
for (Element c : te.getEnclosedElements()) {
for (AnnotationMirror am : c.getAnnotationMirrors()) {
Element ate = am.getAnnotationType().asElement();
if (isSimpleName(ate, "ExpectInterfaces")) {
checkInterfaces((TypeElement) c, getValue(am));
} else if (isSimpleName(ate, "ExpectSupertype")) {
checkSupertype((TypeElement) c, getValue(am));
}
}
}
}
}
return true;
}
String gwtCompatibleAnnotationString() {
if (gwtCompatibleAnnotation.isPresent()) {
AnnotationMirror annotation = gwtCompatibleAnnotation.get();
TypeElement annotationElement = (TypeElement) annotation.getAnnotationType().asElement();
String annotationArguments;
if (annotation.getElementValues().isEmpty()) {
annotationArguments = "";
} else {
List<String> elements = Lists.newArrayList();
for (Map.Entry<ExecutableElement, AnnotationValue> entry :
Collections.unmodifiableMap(annotation.getElementValues()).entrySet()) {
elements.add(entry.getKey().getSimpleName() + " = " + entry.getValue());
}
annotationArguments = "(" + Joiner.on(", ").join(elements) + ")";
}
return "@" + annotationElement.getQualifiedName() + annotationArguments;
} else {
return "";
}
}
private static VariableElement getAutoTypeParameter(
ExecutableElement method, VariableElement target_parameter) {
for (VariableElement param : method.getParameters()) {
AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
if (auto_annotation != null) {
Class annotation_type =
NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
String parameter_name;
if (annotation_type.equals(AutoType.class)) {
parameter_name = param.getAnnotation(AutoType.class).value();
} else if (annotation_type.equals(AutoSize.class)) {
parameter_name = param.getAnnotation(AutoSize.class).value();
} else {
throw new RuntimeException("Unknown annotation type " + annotation_type);
}
if (target_parameter.getSimpleName().toString().equals(parameter_name)) {
return param;
}
}
}
return null;
}
/** Returns whether the field {@code f} is unused, given the annotations on the receiver. */
private boolean isUnused(
VariableTree field, Collection<? extends AnnotationMirror> receiverAnnos) {
if (receiverAnnos.isEmpty()) {
return false;
}
AnnotationMirror unused =
getDeclAnnotation(TreeUtils.elementFromDeclaration(field), Unused.class);
if (unused == null) {
return false;
}
Name when = AnnotationUtils.getElementValueClassName(unused, "when", false);
for (AnnotationMirror anno : receiverAnnos) {
Name annoName = ((TypeElement) anno.getAnnotationType().asElement()).getQualifiedName();
if (annoName.contentEquals(when)) {
return true;
}
}
return false;
}
/**
* INTERNAL: The pre-processing stages requires some knowledge of the annotation values (e.g.
* targetEntity) so we will visit the annotation values and build complete MetadataAnnotation from
* the mirrors.
*/
protected void buildMetadataAnnotations(
MetadataAnnotatedElement annotatedElement,
List<? extends AnnotationMirror> annotationMirrors) {
AnnotationValueVisitor<Object, Object> visitor = new AnnotationValueVisitor<Object, Object>();
for (AnnotationMirror annotationMirror : annotationMirrors) {
String annotation = annotationMirror.getAnnotationType().toString();
// Only add annotations that we care about. Be nice to have API
// that we could call into with the annotation mirror to the
// processor to see if it is a supported annotation. That is, it
// would tie into the @SupportedAnnotationTypes({"javax.persistence.*",
// "org.eclipse.persistence.annotations.*"})
// declaration from CanonicalModelProcessor, but I couldn't find a
// way to do this. For now we'll check the strings (similar to what
// is done with our ASM factory).
if (annotation.contains(JPA_PERSISTENCE_PACKAGE_PREFIX)
|| annotation.contains(ECLIPSELINK_PERSISTENCE_PACKAGE_PREFIX)) {
annotatedElement.addAnnotation(
(MetadataAnnotation) visitor.visitAnnotation(annotationMirror, null));
}
}
}
private void verifyExclusiveMethodAnnotation(Template template, Class<?>... annotationTypes) {
List<ExecutableElement> methods =
ElementFilter.methodsIn(template.getTemplateType().getEnclosedElements());
for (ExecutableElement method : methods) {
List<AnnotationMirror> foundAnnotations = new ArrayList<>();
for (int i = 0; i < annotationTypes.length; i++) {
Class<?> annotationType = annotationTypes[i];
AnnotationMirror mirror =
ElementUtils.findAnnotationMirror(context.getEnvironment(), method, annotationType);
if (mirror != null) {
foundAnnotations.add(mirror);
}
}
if (foundAnnotations.size() > 1) {
List<String> annotationNames = new ArrayList<>();
for (AnnotationMirror mirror : foundAnnotations) {
annotationNames.add("@" + ElementUtils.getSimpleName(mirror.getAnnotationType()));
}
template.addError("Non exclusive usage of annotations %s.", annotationNames);
}
}
}
/**
* Inject extra bound fields into a classInfo.
*
* @param extraBoundFields a list that represents the extra fields defined inside a @{@link
* BoundBox} annotation.
* @param classInfo representation of the class whose BoundBox will receive the extra fields.
*/
private void injectExtraBoundFields(
List<? extends AnnotationValue> extraBoundFields, ClassInfo classInfo) {
if (extraBoundFields == null || extraBoundFields.isEmpty()) {
return;
}
List<FieldInfo> listFieldInfos = classInfo.getListFieldInfos();
TypeMirror fieldClass = null;
String fieldName = null;
for (AnnotationValue annotationValue : extraBoundFields) {
AnnotationMirror annotationMirror = (AnnotationMirror) annotationValue.getValue();
log.info("mirror " + annotationMirror.getAnnotationType());
Map<? extends ExecutableElement, ? extends AnnotationValue>
mapExecutableElementToAnnotationValue = annotationMirror.getElementValues();
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
mapExecutableElementToAnnotationValue.entrySet()) {
if (BOUNDBOX_ANNOTATION_PARAMETER_EXTRA_BOUND_FIELDS_FIELD_NAME.equals(
entry.getKey().getSimpleName().toString())) {
fieldName = getAnnotationValueAsString(entry.getValue());
// TODO shoot an error if its null or not a valid field name in java
}
if (BOUNDBOX_ANNOTATION_PARAMETER_EXTRA_BOUND_FIELDS_FIELD_CLASS.equals(
entry.getKey().getSimpleName().toString())) {
fieldClass = (TypeMirror) entry.getValue().getValue();
}
}
FieldInfo fieldInfo = new FieldInfo(fieldName, fieldClass);
// TODO we should add a warning to the developer here.
// TODO there can even be an error if a field of the same name but with a different type
// exists.
if (!listFieldInfos.contains(fieldInfo)) {
listFieldInfos.add(fieldInfo);
}
}
}
private void processLabels(TypeElement resourcesType, List<LabelTemplateMethod> methods) {
for (Element element : resourcesType.getEnclosedElements()) {
if (element.getKind() != ElementKind.METHOD) {
continue;
}
final ExecutableElement method = (ExecutableElement) element;
Message labelAnnotation = element.getAnnotation(Message.class);
final TemplateParam returnType = new TemplateParam(method.getReturnType().toString());
final boolean deprecated = method.getAnnotation(Deprecated.class) != null;
final LabelTemplateMethod labelMethod;
try {
labelMethod =
new LabelTemplateMethod(
method.getSimpleName().toString(),
deprecated,
returnType,
labelAnnotation.value(),
labelAnnotation.mobile());
} catch (Throwable t) {
processingEnv.getMessager().printMessage(Kind.WARNING, t.getMessage(), resourcesType);
continue;
}
for (VariableElement variable : method.getParameters()) {
final String paramName = variable.getSimpleName().toString();
final String paramType = variable.asType().toString();
List<TemplateAnnotation> annotations = new ArrayList<TemplateAnnotation>();
for (AnnotationMirror annotationMirrors : variable.getAnnotationMirrors()) {
annotations.add(new TemplateAnnotation(annotationMirrors.getAnnotationType().toString()));
}
labelMethod.getParams().add(new TemplateParam(paramType, paramName, annotations));
}
methods.add(labelMethod);
}
}
@Override
public Void visitAnnotation(AnnotationMirror annotation, AnnotationValue unused) {
// By explicitly adding annotations rather than relying on AnnotationMirror.toString(),
// we can import the types and make the code (hopefully) more readable.
code.add("@%s", QualifiedName.of(asElement(annotation.getAnnotationType())));
if (annotation.getElementValues().isEmpty()) {
return null;
}
code.add("(");
if (hasSingleValueWithDefaultKey(annotation)) {
AnnotationValue value = getOnlyElement(annotation.getElementValues().values());
visit(value, value);
} else {
String separator = "";
for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
annotation.getElementValues().entrySet()) {
code.add("%s%s = ", separator, entry.getKey().getSimpleName());
visit(entry.getValue(), entry.getValue());
separator = ", ";
}
}
code.add(")");
return null;
}
public boolean hasErrors(final TypeElement typeElement) {
isClass(typeElement);
isNotNested(typeElement);
final MethodValidator methodValidator = new MethodValidator(this.messager);
for (final ExecutableElement executableElement :
ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
boolean symbol = false;
for (final AnnotationMirror annotationMirror : executableElement.getAnnotationMirrors()) {
if (annotationMirror
.getAnnotationType()
.asElement()
.getSimpleName()
.toString()
.equals(Symbol.class.getSimpleName())) {
symbol = true;
break;
}
}
// validate as C symbol
if (symbol) {
methodValidator.validateSymbol(executableElement);
} else {
// validate as C method
methodValidator.validateIfNative(executableElement);
}
}
this.error |= methodValidator.errorRaised();
return this.error;
}
@Override
public StringBuffer generate(
final String packageName,
final PackageElement packageElement,
final String className,
final Element element,
final ProcessingEnvironment processingEnvironment)
throws GenerationException {
final Messager messager = processingEnvironment.getMessager();
messager.printMessage(Kind.NOTE, "Starting code generation for [" + className + "]");
final Elements elementUtils = processingEnvironment.getElementUtils();
// Extract required information
final TypeElement classElement = (TypeElement) element;
final String annotationName = ClientAPIModule.getWorkbenchScreenClass();
String identifier = null;
Integer preferredHeight = null;
Integer preferredWidth = null;
for (final AnnotationMirror am : classElement.getAnnotationMirrors()) {
if (annotationName.equals(am.getAnnotationType().toString())) {
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
am.getElementValues().entrySet()) {
AnnotationValue aval = entry.getValue();
if ("identifier".equals(entry.getKey().getSimpleName().toString())) {
identifier = aval.getValue().toString();
} else if ("preferredHeight".equals(entry.getKey().getSimpleName().toString())) {
final int _preferredHeight = (Integer) aval.getValue();
if (_preferredHeight > 0) {
preferredHeight = _preferredHeight;
}
} else if ("preferredWidth".equals(entry.getKey().getSimpleName().toString())) {
final int _preferredWidth = (Integer) aval.getValue();
if (_preferredWidth > 0) {
preferredWidth = _preferredWidth;
}
}
}
break;
}
}
final String owningPlace =
GeneratorUtils.getOwningPerspectivePlaceRequest(classElement, processingEnvironment);
final String beanActivatorClass =
GeneratorUtils.getBeanActivatorClassName(classElement, processingEnvironment);
final ExecutableElement onStartupMethod =
GeneratorUtils.getOnStartupMethodForNonEditors(classElement, processingEnvironment);
final String onStartup0ParameterMethodName;
final String onStartup1ParameterMethodName;
if (onStartupMethod == null) {
onStartup0ParameterMethodName = null;
onStartup1ParameterMethodName = null;
} else if (onStartupMethod.getParameters().isEmpty()) {
onStartup0ParameterMethodName = onStartupMethod.getSimpleName().toString();
onStartup1ParameterMethodName = null;
} else {
onStartup0ParameterMethodName = null;
onStartup1ParameterMethodName = onStartupMethod.getSimpleName().toString();
}
final String onMayCloseMethodName =
GeneratorUtils.getOnMayCloseMethodName(classElement, processingEnvironment);
final String onCloseMethodName =
GeneratorUtils.getOnCloseMethodName(classElement, processingEnvironment);
final String onShutdownMethodName =
GeneratorUtils.getOnShutdownMethodName(classElement, processingEnvironment);
final String onOpenMethodName =
GeneratorUtils.getOnOpenMethodName(classElement, processingEnvironment);
final String onLostFocusMethodName =
GeneratorUtils.getOnLostFocusMethodName(classElement, processingEnvironment);
final String onFocusMethodName =
GeneratorUtils.getOnFocusMethodName(classElement, processingEnvironment);
final String getDefaultPositionMethodName =
GeneratorUtils.getDefaultPositionMethodName(classElement, processingEnvironment);
final String getTitleMethodName =
GeneratorUtils.getTitleMethodName(classElement, processingEnvironment);
final String getContextIdMethodName =
GeneratorUtils.getContextIdMethodName(classElement, processingEnvironment);
final ExecutableElement getTitleWidgetMethod =
GeneratorUtils.getTitleWidgetMethodName(classElement, processingEnvironment);
final String getTitleWidgetMethodName =
getTitleWidgetMethod == null ? null : getTitleWidgetMethod.getSimpleName().toString();
final ExecutableElement getWidgetMethod =
GeneratorUtils.getWidgetMethodName(classElement, processingEnvironment);
final String getWidgetMethodName =
getWidgetMethod == null ? null : getWidgetMethod.getSimpleName().toString();
final boolean hasUberView =
GeneratorUtils.hasUberViewReference(classElement, processingEnvironment, getWidgetMethod);
final boolean isWidget = GeneratorUtils.getIsWidget(classElement, processingEnvironment);
final String getMenuBarMethodName =
GeneratorUtils.getMenuBarMethodName(classElement, processingEnvironment);
final String getToolBarMethodName =
GeneratorUtils.getToolBarMethodName(classElement, processingEnvironment);
final String securityTraitList =
GeneratorUtils.getSecurityTraitList(elementUtils, classElement);
final String rolesList = GeneratorUtils.getRoleList(elementUtils, classElement);
if (GeneratorUtils.debugLoggingEnabled()) {
messager.printMessage(Kind.NOTE, "Package name: " + packageName);
messager.printMessage(Kind.NOTE, "Class name: " + className);
messager.printMessage(Kind.NOTE, "Identifier: " + identifier);
messager.printMessage(Kind.NOTE, "Owning Perspective Identifier: " + owningPlace);
messager.printMessage(Kind.NOTE, "Preferred Height: " + preferredHeight);
messager.printMessage(Kind.NOTE, "Preferred Width: " + preferredWidth);
messager.printMessage(Kind.NOTE, "getContextIdMethodName: " + getContextIdMethodName);
messager.printMessage(
Kind.NOTE, "onStartup0ParameterMethodName: " + onStartup0ParameterMethodName);
messager.printMessage(
Kind.NOTE, "onStartup1ParameterMethodName: " + onStartup1ParameterMethodName);
messager.printMessage(Kind.NOTE, "onMayCloseMethodName: " + onMayCloseMethodName);
messager.printMessage(Kind.NOTE, "onCloseMethodName: " + onCloseMethodName);
messager.printMessage(Kind.NOTE, "onShutdownMethodName: " + onShutdownMethodName);
messager.printMessage(Kind.NOTE, "onOpenMethodName: " + onOpenMethodName);
messager.printMessage(Kind.NOTE, "onLostFocusMethodName: " + onLostFocusMethodName);
messager.printMessage(Kind.NOTE, "onFocusMethodName: " + onFocusMethodName);
messager.printMessage(
Kind.NOTE, "getDefaultPositionMethodName: " + getDefaultPositionMethodName);
messager.printMessage(Kind.NOTE, "getTitleMethodName: " + getTitleMethodName);
messager.printMessage(Kind.NOTE, "getTitleWidgetMethodName: " + getTitleWidgetMethodName);
messager.printMessage(Kind.NOTE, "getWidgetMethodName: " + getWidgetMethodName);
messager.printMessage(Kind.NOTE, "isWidget: " + Boolean.toString(isWidget));
messager.printMessage(Kind.NOTE, "hasUberView: " + Boolean.toString(hasUberView));
messager.printMessage(Kind.NOTE, "getMenuBarMethodName: " + getMenuBarMethodName);
messager.printMessage(Kind.NOTE, "getToolBarMethodName: " + getToolBarMethodName);
messager.printMessage(Kind.NOTE, "securityTraitList: " + securityTraitList);
messager.printMessage(Kind.NOTE, "rolesList: " + rolesList);
}
// Validate getWidgetMethodName and isWidget
if (!isWidget && getWidgetMethodName == null) {
throw new GenerationException(
"The WorkbenchScreen must either extend IsWidget or provide a @WorkbenchPartView annotated method to return a com.google.gwt.user.client.ui.IsWidget.",
packageName + "." + className);
}
if (isWidget && getWidgetMethodName != null) {
final String msg =
"The WorkbenchScreen both extends com.google.gwt.user.client.ui.IsWidget and provides a @WorkbenchPartView annotated method. The annotated method will take precedence.";
messager.printMessage(Kind.WARNING, msg, classElement);
}
// Validate getTitleMethodName and getTitleWidgetMethodName
if (getTitleMethodName == null) {
throw new GenerationException(
"The WorkbenchScreen must provide a @WorkbenchPartTitle annotated method to return a java.lang.String.",
packageName + "." + className);
}
// Setup data for template sub-system
Map<String, Object> root = new HashMap<String, Object>();
root.put("packageName", packageName);
root.put("className", className);
root.put("identifier", identifier);
root.put("owningPlace", owningPlace);
root.put("preferredHeight", preferredHeight);
root.put("preferredWidth", preferredWidth);
root.put("getContextIdMethodName", getContextIdMethodName);
root.put("realClassName", classElement.getSimpleName().toString());
root.put("beanActivatorClass", beanActivatorClass);
root.put("onStartup0ParameterMethodName", onStartup0ParameterMethodName);
root.put("onStartup1ParameterMethodName", onStartup1ParameterMethodName);
root.put("onMayCloseMethodName", onMayCloseMethodName);
root.put("onCloseMethodName", onCloseMethodName);
root.put("onShutdownMethodName", onShutdownMethodName);
root.put("onOpenMethodName", onOpenMethodName);
root.put("onLostFocusMethodName", onLostFocusMethodName);
root.put("onFocusMethodName", onFocusMethodName);
root.put("getDefaultPositionMethodName", getDefaultPositionMethodName);
root.put("getTitleMethodName", getTitleMethodName);
root.put("getTitleWidgetMethodName", getTitleWidgetMethodName);
root.put("getWidgetMethodName", getWidgetMethodName);
root.put("isWidget", isWidget);
root.put("hasUberView", hasUberView);
root.put("getMenuBarMethodName", getMenuBarMethodName);
root.put("getToolBarMethodName", getToolBarMethodName);
root.put("securityTraitList", securityTraitList);
root.put("rolesList", rolesList);
// Generate code
final StringWriter sw = new StringWriter();
final BufferedWriter bw = new BufferedWriter(sw);
try {
final Template template = config.getTemplate("activityScreen.ftl");
template.process(root, bw);
} catch (IOException ioe) {
throw new GenerationException(ioe);
} catch (TemplateException te) {
throw new GenerationException(te);
} finally {
try {
bw.close();
sw.close();
} catch (IOException ioe) {
throw new GenerationException(ioe);
}
}
messager.printMessage(Kind.NOTE, "Successfully generated code for [" + className + "]");
return sw.getBuffer();
}
private static boolean printMethodCallArgument(
PrintWriter writer,
ExecutableElement method,
VariableElement param,
Map<VariableElement, TypeInfo> typeinfos_instance,
Mode mode,
boolean first_parameter,
TypeMap type_map) {
if (!first_parameter) {
writer.print(", ");
}
AnnotationMirror auto_annotation = Utils.getParameterAutoAnnotation(param);
Constant constant_annotation = param.getAnnotation(Constant.class);
if (constant_annotation != null) {
writer.print(constant_annotation.value());
} else if (auto_annotation != null && mode == Mode.NORMAL) {
Class param_type = NativeTypeTranslator.getClassFromType(auto_annotation.getAnnotationType());
if (AutoType.class.equals(param_type)) {
final AutoType auto_type_annotation = param.getAnnotation(AutoType.class);
final VariableElement auto_parameter =
Utils.findParameter(method, auto_type_annotation.value());
final String auto_type = typeinfos_instance.get(auto_parameter).getAutoType();
if (auto_type == null) {
throw new RuntimeException(
"No auto type for parameter " + param.getSimpleName() + " in method " + method);
}
writer.print(auto_type);
} else if (AutoSize.class.equals(param_type)) {
final AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if (!auto_size_annotation.useExpression()) {
final String auto_parameter_name = auto_size_annotation.value();
final VariableElement auto_target_param =
Utils.findParameter(method, auto_parameter_name);
final TypeInfo auto_target_type_info = typeinfos_instance.get(auto_target_param);
final boolean shift_remaining =
!hasAnyParameterAutoTypeAnnotation(method, auto_target_param)
&& Utils.isParameterMultiTyped(auto_target_param);
int shifting = 0;
if (shift_remaining) {
shifting = getBufferElementSizeExponent(auto_target_type_info.getType());
if (shifting > 0) {
writer.print("(");
}
}
if (auto_size_annotation.canBeNull()) {
writer.print(
"("
+ auto_parameter_name
+ " == null ? 0 : "
+ auto_parameter_name
+ ".remaining())");
} else {
writer.print(auto_parameter_name + ".remaining()");
}
// Shift the remaining if the target parameter is multityped and there's no AutoType to
// track type
if (shift_remaining && shifting > 0) {
writer.print(" << " + shifting);
writer.print(")");
}
}
writer.print(auto_size_annotation.expression());
} else {
throw new RuntimeException("Unknown auto annotation " + param_type);
}
} else {
if (mode == Mode.BUFFEROBJECT && param.getAnnotation(BufferObject.class) != null) {
writer.print(param.getSimpleName() + Utils.BUFFER_OBJECT_PARAMETER_POSTFIX);
} else {
Class type = typeinfos_instance.get(param).getType();
Check check_annotation = param.getAnnotation(Check.class);
boolean hide_buffer = mode == Mode.AUTOS && getAutoTypeParameter(method, param) != null;
if (hide_buffer) {
writer.print("0L");
} else {
if (type == CharSequence.class || type == CharSequence[].class) {
final String offset = Utils.getStringOffset(method, param);
writer.print("APIUtil.getBuffer");
if (param.getAnnotation(NullTerminated.class) != null) {
writer.print("NT");
}
writer.print('(');
writer.print(type_map.getAPIUtilParam(true));
writer.print(param.getSimpleName());
if (offset != null) {
writer.print(", " + offset);
}
writer.print(")");
} else {
final AutoSize auto_size_annotation = param.getAnnotation(AutoSize.class);
if (auto_size_annotation != null) {
writer.print(auto_size_annotation.value() + "_");
}
final Class buffer_type = Utils.getNIOBufferType(param.asType());
if (buffer_type == null) {
writer.print(param.getSimpleName());
} else {
writer.print("MemoryUtil.getAddress");
if (check_annotation != null && check_annotation.canBeNull()) {
writer.print("Safe");
}
writer.print("(");
writer.print(param.getSimpleName());
writer.print(")");
}
}
}
if (type != long.class) {
PointerWrapper pointer_annotation = param.getAnnotation(PointerWrapper.class);
if (pointer_annotation != null) {
if (pointer_annotation.canBeNull()) {
writer.print(" == null ? 0 : " + param.getSimpleName());
}
writer.print(".getPointer()");
}
}
}
}
return false;
}
@Override
public boolean process(
final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnvironment) {
// Get all classes that has the annotation
Set<? extends Element> classElements =
roundEnvironment.getElementsAnnotatedWith(BoundBox.class);
// For each class that has the annotation
for (final Element classElement : classElements) {
// Get the annotation information
TypeElement boundClass = null;
String maxSuperClass = null;
String[] prefixes = null;
String boundBoxPackageName = null;
List<? extends AnnotationValue> extraBoundFields = null;
List<? extends AnnotationMirror> listAnnotationMirrors = classElement.getAnnotationMirrors();
if (listAnnotationMirrors == null) {
messager.printMessage(Kind.WARNING, "listAnnotationMirrors is null", classElement);
return true;
}
StringBuilder message = new StringBuilder();
for (AnnotationMirror annotationMirror : listAnnotationMirrors) {
log.info("mirror " + annotationMirror.getAnnotationType());
Map<? extends ExecutableElement, ? extends AnnotationValue> map =
annotationMirror.getElementValues();
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
map.entrySet()) {
message.append(entry.getKey().getSimpleName().toString());
message.append("\n");
message.append(entry.getValue().toString());
if (BOUNDBOX_ANNOTATION_PARAMETER_BOUND_CLASS.equals(
entry.getKey().getSimpleName().toString())) {
boundClass = getAnnotationValueAsTypeElement(entry.getValue());
}
if (BOUNDBOX_ANNOTATION_PARAMETER_MAX_SUPER_CLASS.equals(
entry.getKey().getSimpleName().toString())) {
maxSuperClass = getAnnotationValueAsTypeElement(entry.getValue()).asType().toString();
}
if (BOUNDBOX_ANNOTATION_PARAMETER_EXTRA_BOUND_FIELDS.equals(
entry.getKey().getSimpleName().toString())) {
extraBoundFields = getAnnotationValueAsAnnotationValueList(entry.getValue());
}
if (BOUNDBOX_ANNOTATION_PARAMETER_PREFIXES.equals(
entry.getKey().getSimpleName().toString())) {
List<? extends AnnotationValue> listPrefixes =
getAnnotationValueAsAnnotationValueList(entry.getValue());
prefixes = new String[listPrefixes.size()];
for (int indexAnnotation = 0;
indexAnnotation < listPrefixes.size();
indexAnnotation++) {
prefixes[indexAnnotation] =
getAnnotationValueAsString(listPrefixes.get(indexAnnotation));
}
}
if (BOUNDBOX_ANNOTATION_PARAMETER_PACKAGE.equals(
entry.getKey().getSimpleName().toString())) {
boundBoxPackageName = getAnnotationValueAsString(entry.getValue());
}
}
}
if (boundClass == null) {
messager.printMessage(Kind.WARNING, "BoundClass is null : " + message, classElement);
return true;
}
if (maxSuperClass != null) {
boundClassVisitor.setMaxSuperClassName(maxSuperClass);
}
if (prefixes != null && prefixes.length != 2 && prefixes.length != 1) {
error(
classElement,
"You must provide 1 or 2 prefixes. The first one for class names, the second one for methods.");
return true;
}
if (prefixes != null && prefixes.length == 1) {
String[] newPrefixes = new String[] {prefixes[0], prefixes[0].toLowerCase(Locale.US)};
prefixes = newPrefixes;
}
boundboxWriter.setPrefixes(prefixes);
if (boundBoxPackageName == null) {
String boundClassFQN = boundClass.getQualifiedName().toString();
if (boundClassFQN.contains(PACKAGE_SEPARATOR)) {
boundBoxPackageName = StringUtils.substringBeforeLast(boundClassFQN, PACKAGE_SEPARATOR);
} else {
boundBoxPackageName = StringUtils.EMPTY;
}
}
boundClassVisitor.setBoundBoxPackageName(boundBoxPackageName);
boundboxWriter.setBoundBoxPackageName(boundBoxPackageName);
ClassInfo classInfo = boundClassVisitor.scan(boundClass);
injectExtraBoundFields(extraBoundFields, classInfo);
listClassInfo.add(classInfo);
// perform some computations on meta model
inheritanceComputer.computeInheritanceAndHidingFields(classInfo.getListFieldInfos());
inheritanceComputer.computeInheritanceAndOverridingMethods(
classInfo.getListMethodInfos(), boundClass, elements);
inheritanceComputer.computeInheritanceAndHidingInnerClasses(
classInfo.getListInnerClassInfo());
inheritanceComputer.computeInheritanceInInnerClasses(classInfo, elements);
// write meta model to java class file
Writer sourceWriter = null;
try {
String boundBoxClassName =
boundboxWriter.getNamingGenerator().createBoundBoxName(classInfo);
String boundBoxClassFQN =
boundBoxPackageName.isEmpty()
? boundBoxClassName
: boundBoxPackageName + PACKAGE_SEPARATOR + boundBoxClassName;
JavaFileObject sourceFile = filer.createSourceFile(boundBoxClassFQN, (Element[]) null);
sourceWriter = sourceFile.openWriter();
boundboxWriter.writeBoundBox(classInfo, sourceWriter);
} catch (IOException e) {
e.printStackTrace();
error(classElement, e.getMessage());
} finally {
if (sourceWriter != null) {
IOUtils.closeQuietly(sourceWriter);
}
}
}
return true;
}
