How to use

isEmpty

method

in

com.yahoo.aptutils.utils.AptUtils

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!");
}