private Set<String> parseOptions() { Set<String> result = new HashSet<>(); String optionsString = envOptions.get(OPTIONS_KEY); if (!AptUtils.isEmpty(optionsString)) { String[] allOptions = optionsString.split(SEPARATOR); Collections.addAll(result, allOptions); } return result; }
private void initializePluginsFromEnvironment() { String pluginsString = envOptions.get(PLUGINS_KEY); if (!AptUtils.isEmpty(pluginsString)) { String[] allPlugins = pluginsString.split(SEPARATOR); for (String plugin : allPlugins) { processPlugin(plugin); } } }
/** * @return true if the table model is for a virtual table, false otherwise */ public boolean isVirtualTable() { return !AptUtils.isEmpty(modelSpecAnnotation.virtualModule()); }
public static boolean isPrimitiveType(DeclaredTypeName type) { return AptUtils.isEmpty(type.getPackageName()); }
private void reportUnsupportedOptions() { Set<String> unsupportedOptions = new HashSet<>(squidbOptions); unsupportedOptions.removeAll(SQUIDB_SUPPORTED_OPTIONS); if (AptUtils.isEmpty(unsupportedOptions)) { return; } StringBuilder sb = new StringBuilder(); for (String option : unsupportedOptions) { if (sb.length() > 0) { sb.append(SEPARATOR); } sb.append(option); } String message = String.format(UNSUPPORTED_OPTIONS_WARNING, sb); utils.getMessager().printMessage(Diagnostic.Kind.WARNING, message); }
private String getColumnName(ColumnSpec columnDef) { if (columnDef != null && !AptUtils.isEmpty(columnDef.name().trim())) { return columnDef.name().trim(); } return camelCasePropertyName; }
@Override protected void registerAdditionalImports(Set<DeclaredTypeName> imports) { super.registerAdditionalImports(imports); imports.add(JSONTypes.JSON_PROPERTY_SUPPORT); imports.add(JSONTypes.JSON_PROPERTY); if (!AptUtils.isEmpty(fieldType.getTypeArgs())) { imports.add(JSONTypes.PARAMETERIZED_TYPE_BUILDER); } fieldType.accept(new ImportGatheringTypeNameVisitor(), imports); }
private void logSingleError(AnnotationValue singleErrorAnnotation) { AnnotationMirror singleErrorMirror = (AnnotationMirror) singleErrorAnnotation.getValue(); TypeMirror errorClass = utils.getTypeMirrorsFromAnnotationValue( utils.getAnnotationValueFromMirror(singleErrorMirror, "specClass")).get(0); String errorMessage = utils.getValuesFromAnnotationValue( utils.getAnnotationValueFromMirror(singleErrorMirror, "message"), String.class).get(0); List<String> errorElementValues = utils.getValuesFromAnnotationValue( utils.getAnnotationValueFromMirror(singleErrorMirror, "element"), String.class); String errorElementName = AptUtils.isEmpty(errorElementValues) ? null : errorElementValues.get(0); Element errorElement = findErrorElement(errorClass, errorElementName); utils.getMessager().printMessage(Diagnostic.Kind.ERROR, errorMessage, errorElement); }
private boolean recursivelyCheckTypes(VariableElement field, TypeName rootType, AtomicBoolean showedError) { if (!(rootType instanceof DeclaredTypeName)) { return false; } List<? extends TypeName> typeArgs = ((DeclaredTypeName) rootType).getTypeArgs(); if (AptUtils.isEmpty(typeArgs)) { return true; } for (TypeName typeArg : typeArgs) { if (!recursivelyCheckTypes(field, typeArg, showedError)) { if (!showedError.getAndSet(true)) { modelSpec.logError( "@JSONField fields with type arguments" + " must not use generic or otherwise non-concrete types", field); } return false; } } return true; }
@Override public void emitPropertyDeclaration(JavaFileWriter writer) throws IOException { if (isDeprecated) { writer.writeAnnotation(CoreTypes.DEPRECATED); } List<Object> constructorArgs = new ArrayList<>(); constructorArgs.add(TableModelFileWriter.TABLE_MODEL_NAME); constructorArgs.add("\"" + columnName + "\""); String columnDef = getColumnDefinition(); if (!AptUtils.isEmpty(columnDef)) { constructorArgs.add(columnDef); } writer.writeFieldDeclaration(getPropertyType(), propertyName, Expressions.callConstructor(getPropertyType(), constructorArgs), TypeConstants.PUBLIC_STATIC_FINAL); }
private Expression getTypeExpression(DeclaredTypeName fieldType) { List<? extends TypeName> typeArgs = fieldType.getTypeArgs(); if (AptUtils.isEmpty(typeArgs)) { return Expressions.classObject(fieldType); } else { List<Expression> parameterizedTypeBuilderArgs = new ArrayList<>(); parameterizedTypeBuilderArgs.add(Expressions.classObject(fieldType)); for (TypeName typeArg : typeArgs) { // The cast to DeclaredTypeName is safe because we recursively check all type args before constructing // an instance of this property generator parameterizedTypeBuilderArgs.add(getTypeExpression((DeclaredTypeName) typeArg)); } return Expressions.staticMethod(JSONTypes.PARAMETERIZED_TYPE_BUILDER, "build", parameterizedTypeBuilderArgs); } }
if (!AptUtils.isEmpty(toReturnString)) { return "\"" + toReturnString + "\"";
if (AptUtils.isEmpty(identifier)) { modelSpec.logError(type + " name cannot be null or empty", element); return false;
List<DeclaredTypeName> typeNames = utils.getTypeNamesFromAnnotationValue( utils.getAnnotationValue(modelSpecElement, Implements.class, "interfaceClasses")); if (!AptUtils.isEmpty(typeNames)) { interfaces.addAll(typeNames); AnnotationValue interfaceClassValue = utils.getAnnotationValueFromMirror(spec, "interfaceClass"); List<DeclaredTypeName> interfaceClassList = utils.getTypeNamesFromAnnotationValue(interfaceClassValue); if (!AptUtils.isEmpty(interfaceClassList)) { DeclaredTypeName interfaceClass = interfaceClassList.get(0); .getAnnotationValueFromMirror(spec, "interfaceTypeArgs"); List<DeclaredTypeName> typeArgs = utils.getTypeNamesFromAnnotationValue(interfaceTypeArgsValue); if (AptUtils.isEmpty(typeArgs)) { List<String> typeArgNames = utils.getValuesFromAnnotationValue( utils.getAnnotationValueFromMirror(spec, "interfaceTypeArgNames"), String.class);
private boolean emitPropertyReferenceArrayBody(boolean alias) throws IOException { for (PropertyGenerator propertyGenerator : modelSpec.getPropertyGenerators()) { Expression reference = Expressions.staticReference(modelSpec.getModelSpecName(), propertyGenerator.getPropertyName()); if (alias) { VariableElement field = propertyGenerator.getField(); if (field != null) { Alias aliasAnnotation = field.getAnnotation(Alias.class); if (aliasAnnotation != null && !AptUtils.isEmpty(aliasAnnotation.value().trim())) { reference = reference.callMethod("as", "\"" + aliasAnnotation.value().trim() + "\""); } } } writer.writeExpression(reference); writer.appendString(",\n"); } return !AptUtils.isEmpty(modelSpec.getPropertyGenerators()); }
@Override public void beforeEmitClassDeclaration(JavaFileWriter writer) throws IOException { String generatedJavadoc = " This class was generated from the model spec at " + "{@link " + modelSpec.getModelSpecName() + "}"; String elementJavadoc = utils.getElements().getDocComment(modelSpec.getModelSpecElement()); if (!AptUtils.isEmpty(elementJavadoc)) { generatedJavadoc = (generatedJavadoc + "\n <br/>\n" + elementJavadoc); } writer.writeJavadoc(generatedJavadoc); writer.writeComment("Generated code -- do not modify!"); }
private void emitModelMethod(JavaFileWriter writer, ExecutableElement e, Modifier... modifiers) throws IOException { MethodDeclarationParameters params = utils.methodDeclarationParamsFromExecutableElement(e, modifiers); ModelMethod methodAnnotation = e.getAnnotation(ModelMethod.class); List<Object> arguments = new ArrayList<>(); if (methodAnnotation != null) { String name = methodAnnotation.name(); if (!AptUtils.isEmpty(name)) { params.setMethodName(name); } params.getArgumentTypes().remove(0); params.getArgumentNames().remove(0); arguments.add(0, "this"); } arguments.addAll(params.getArgumentNames()); Expression methodCall = Expressions.staticMethod(modelSpec.getModelSpecName(), e.getSimpleName().toString(), arguments); if (!CoreTypes.VOID.equals(params.getReturnType())) { methodCall = methodCall.returnExpr(); } JavadocPlugin.writeJavadocFromElement(pluginEnv, writer, e); writer.beginMethodDefinition(params) .writeStatement(methodCall) .finishMethodDefinition(); }
private void emitTableDeclaration() throws IOException { writer.writeComment("--- table declaration"); List<Object> arguments = new ArrayList<>(); arguments.add(Expressions.classObject(modelSpec.getGeneratedClassName())); // modelClass arguments.add(PROPERTIES_ARRAY_NAME); // properties arguments.add("\"" + modelSpec.getSpecAnnotation().tableName().trim() + "\""); // name arguments.add(null); // database name, null by default if (modelSpec.isVirtualTable()) { if (AptUtils.isEmpty(modelSpec.getSpecAnnotation().virtualModule())) { modelSpec.logError("virtualModule should be non-empty for virtual table models", modelSpec.getModelSpecElement()); } arguments.add("\"" + modelSpec.getSpecAnnotation().virtualModule() + "\""); } else if (!AptUtils.isEmpty(modelSpec.getSpecAnnotation().tableConstraint())) { arguments.add("\"" + modelSpec.getSpecAnnotation().tableConstraint() + "\""); } writer.writeFieldDeclaration(modelSpec.getTableType(), TABLE_NAME, Expressions.callConstructor(modelSpec.getTableType(), arguments), TypeConstants.PUBLIC_STATIC_FINAL); writer.writeFieldDeclaration(TypeConstants.TABLE_MODEL_NAME, TABLE_MODEL_NAME, Expressions.callConstructor(TypeConstants.TABLE_MODEL_NAME, Expressions.classObject(modelSpec.getGeneratedClassName()), Expressions.callMethodOn(TableModelFileWriter.TABLE_NAME, "getName")), TypeConstants.PUBLIC_STATIC_FINAL); writer.writeNewline(); }
@Override public boolean writeExpression(JavaFileWriter writer) throws IOException { writer.appendString("@") .appendString(writer.shortenName(MODEL_GEN_ERROR_INNER, false)) .appendString("(specClass=") .appendExpression(Expressions.classObject(errorInfo.errorClass)) .appendString(", "); if (!AptUtils.isEmpty(errorInfo.element)) { writer.appendString("element=\"") .appendString(errorInfo.element) .appendString("\", "); } writer.appendString("message=\"") .appendString(errorInfo.message) .appendString("\")"); return true; } }
@Override public void beforeEmitClassDeclaration(JavaFileWriter writer) throws IOException { String generatedJavadoc = " This class was generated from the model spec at " + "{@link " + modelSpec.getModelSpecName() + "}"; String elementJavadoc = utils.getElements().getDocComment(modelSpec.getModelSpecElement()); if (!AptUtils.isEmpty(elementJavadoc)) { generatedJavadoc = (generatedJavadoc + "\n <br/>\n" + elementJavadoc); } writer.writeJavadoc(generatedJavadoc); writer.writeComment("Generated code -- do not modify!"); }