How to use

JavaFileWriter

in

com.yahoo.aptutils.writer

private void writeRowidSupportMethods(JavaFileWriter writer, String propertyName)
    throws IOException {
  // Write TABLE.setRowIdProperty call
  writer.beginInitializerBlock(true, true);
  writer.writeStatement(Expressions.callMethodOn(TableModelFileWriter.TABLE_NAME,
      "setRowIdProperty", propertyName));
  writer.finishInitializerBlock(true, true);
  writer.writeNewline();
  // Write getRowIdProperty() method
  writer.writeAnnotation(CoreTypes.OVERRIDE);
  MethodDeclarationParameters params = new MethodDeclarationParameters()
      .setModifiers(Modifier.PUBLIC)
      .setReturnType(TypeConstants.LONG_PROPERTY)
      .setMethodName("getRowIdProperty");
  writer.beginMethodDefinition(params);
  writer.writeStringStatement("return " + propertyName);
  writer.finishMethodDefinition();
}

  @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 emitConstructors(JavaFileWriter writer) throws IOException {
  writer.writeComment("--- default constructors");
  MethodDeclarationParameters params = new MethodDeclarationParameters()
      .setModifiers(Modifier.PUBLIC)
      .setConstructorName(modelSpec.getGeneratedClassName());
  writer.beginConstructorDeclaration(params)
      .writeStringStatement("super()")
      .finishMethodDefinition();
  writer.beginConstructorDeclaration(params)
      .writeStringStatement("this()")
      .writeStringStatement("readPropertiesFromCursor(cursor)")
      .finishMethodDefinition();
  writer.beginConstructorDeclaration(params)
      .writeStatement(Expressions.callMethod("this", valuesName,
          ModelFileWriter.PROPERTIES_ARRAY_NAME))
      .finishMethodDefinition();
  writer.beginConstructorDeclaration(params)
      .writeStringStatement("this()")
      .writeStringStatement(methodName + "(" + valuesName + ", withProperties)")
      .finishMethodDefinition();
  writer.writeAnnotation(CoreTypes.OVERRIDE);
  writer.beginMethodDefinition(cloneParams)
      .writeStatement(cloneBody)
      .finishMethodDefinition();

  @Override
  public boolean writeExpression(JavaFileWriter writer) throws IOException {
    writer.appendExpression(condition)
        .appendString(" ? ")
        .appendExpression(ifTrue)
        .appendString(" : ")
        .appendExpression(ifFalse);
    return true;
  }
}

private void emitTableModelMapper() throws IOException {
  writer.writeComment("--- mappers");
  writer.writeFieldDeclaration(TypeConstants.TABLE_MAPPING_VISITORS, "tableMappingInfo",
      Expressions.callMethod("generateTableMappingVisitors",
          PROPERTIES_ARRAY_NAME, ALIASED_PROPERTY_ARRAY_NAME, BASE_PROPERTY_ARRAY_NAME),
      TypeConstants.PRIVATE_STATIC_FINAL)
      .writeNewline();
  writer.writeAnnotation(CoreTypes.OVERRIDE)
      .beginMethodDefinition(GET_TABLE_MAPPING_VISITORS)
      .writeStringStatement("return tableMappingInfo")
      .finishMethodDefinition();
}

protected void emitDefaultValues() throws IOException {
  writer.writeComment("--- default values");
  writer.writeFieldDeclaration(TypeConstants.VALUES_STORAGE, DEFAULT_VALUES_NAME,
      Expressions.callMethodOn(
          Expressions.callConstructor(modelSpec.getGeneratedClassName()), "newValuesStorage"),
      Modifier.PROTECTED, Modifier.STATIC, Modifier.FINAL);
  if (pluginEnv.hasSquidbOption(PluginEnvironment.OPTIONS_DISABLE_DEFAULT_VALUES)) {
    writer.writeComment("--- property defaults disabled by plugin flag");
  } else {
    writer.beginInitializerBlock(true, true)
        .writeComment("--- put property defaults");
    emitDefaultValuesInitializationBlock();
    writer.finishInitializerBlock(false, true).writeNewline();
  }
  writer.writeAnnotation(CoreTypes.OVERRIDE)
      .beginMethodDefinition(GET_DEFAULT_VALUES_PARAMS)
      .writeStringStatement("return " + DEFAULT_VALUES_NAME)
      .finishMethodDefinition();
}

  @Override
  public boolean writeExpression(JavaFileWriter writer) throws IOException {
    writer.appendString("@")
        .appendString(writer.shortenName(MODEL_GEN_ERRORS, false))
        .appendString("({\n");
    writer.moveToScope(JavaFileWriter.Scope.METHOD_DEFINITION);
    boolean needsNewline = false;
    for (ErrorInfo errorInfo : errors) {
      if (needsNewline) {
        writer.appendString(",").writeNewline();
      }
      needsNewline = true;
      writer.writeExpression(new ModelGenErrorSingle(errorInfo));
    }
    writer.writeNewline();
    writer.finishScope(JavaFileWriter.Scope.METHOD_DEFINITION);
    writer.writeString("})");
    return true;
  }
}

private void emitAliasedPropertyArray() throws IOException {
  writer.writeComment("--- aliased property references");
  Expression aliasedPropertiesInit = Expressions.block(new Expression() {
    @Override
    public boolean writeExpression(JavaFileWriter writer) throws IOException {
      return emitPropertyReferenceArrayBody(true);
    }
  }, false, false, false, false);
  writer.writeFieldDeclaration(TypeConstants.PROPERTY_ARRAY, ALIASED_PROPERTY_ARRAY_NAME,
      aliasedPropertiesInit, TypeConstants.PUBLIC_STATIC_FINAL)
      .writeNewline();
  writer.beginInitializerBlock(true, true);
  writer.writeStatement(Expressions.callMethod("validateAliasedProperties", ALIASED_PROPERTY_ARRAY_NAME));
  writer.finishInitializerBlock(false, true);
  writer.writeNewline();
}

@Override
public void emitAdditionalJava(JavaFileWriter writer) throws IOException {
  List<ErrorInfo> errors = modelSpec.getLoggedErrors();
  if (errors.size() > 0) {
    writer.writeExpression(new ModelGenErrorsExpression(errors))
        .writeNewline();
    TypeDeclarationParameters dummyErrorClass = new TypeDeclarationParameters()
        .setModifiers(Modifier.STATIC, Modifier.FINAL)
        .setName(new DeclaredTypeName(modelSpec.getGeneratedClassName().toString(), "LoggedErrors"))
        .setKind(JavaFileWriter.Type.CLASS);
    writer.beginTypeDefinition(dummyErrorClass);
    writer.writeComment("Dummy class for holding logged error annotations");
    writer.finishTypeDefinition();
  }
}

@Override
public void emitConstructors(JavaFileWriter writer) throws IOException {
  if (generateConstructors) {
    String valuesName = "contentValues";
    DeclaredTypeName valuesType = TypeConstants.CONTENT_VALUES;
    MethodDeclarationParameters params = new MethodDeclarationParameters()
        .setModifiers(Modifier.PUBLIC)
        .setConstructorName(modelSpec.getGeneratedClassName());
    params.setArgumentTypes(Collections.singletonList(valuesType))
        .setArgumentNames(valuesName);
    writer.beginConstructorDeclaration(params)
        .writeStatement(Expressions.callMethod("this", valuesName,
            ModelFileWriter.PROPERTIES_ARRAY_NAME))
        .finishMethodDefinition();
    String methodName = "readPropertiesFromContentValues";
    params.setArgumentTypes(Arrays.asList(valuesType, TypeConstants.PROPERTY_VARARGS))
        .setArgumentNames(valuesName, "withProperties");
    writer.beginConstructorDeclaration(params)
        .writeStringStatement("this()")
        .writeStringStatement(methodName + "(" + valuesName + ", withProperties)")
        .finishMethodDefinition();
  }
}

@Override
public void emitMethods(JavaFileWriter writer) throws IOException {
  // If rowid property generator hasn't already done it, need to generate
  // overridden setRowId with appropriate return type
  if (!pluginEnv.hasSquidbOption(PluginEnvironment.OPTIONS_DISABLE_DEFAULT_GETTERS_AND_SETTERS)) {
    RowidPropertyGenerator rowidPropertyGenerator = modelSpec
        .getMetadata(METADATA_KEY_ROWID_ALIAS_PROPERTY_GENERATOR);
    if (rowidPropertyGenerator != null && !"setRowId".equals(rowidPropertyGenerator.setterMethodName())) {
      MethodDeclarationParameters params = new MethodDeclarationParameters()
          .setModifiers(Modifier.PUBLIC)
          .setMethodName("setRowId")
          .setArgumentTypes(CoreTypes.PRIMITIVE_LONG)
          .setArgumentNames("rowid")
          .setReturnType(modelSpec.getGeneratedClassName());
      writer.writeAnnotation(CoreTypes.OVERRIDE)
          .beginMethodDefinition(params)
          .writeStringStatement("super.setRowId(rowid)")
          .writeStringStatement("return this")
          .finishMethodDefinition();
    }
  }
}

@Override
protected void writeSetterBody(JavaFileWriter writer, MethodDeclarationParameters params) throws IOException {
  String argName = params.getArgumentNames().get(0);
  final String argAsString = argName + "AsString";
  Expression condition = Expressions.fromString(argName + " == null");
  Expression ifTrue = Expressions.fromString("null");
  Expression ifFalse = Expressions.callMethodOn(argName, "name");
  writer.writeFieldDeclaration(CoreTypes.JAVA_STRING, argAsString,
      new TernaryExpression(condition, ifTrue, ifFalse));
  writer.writeStatement(Expressions.callMethod("set", propertyName, argAsString));
  writer.writeStringStatement("return this");
}

/**
 * Subclasses can override this hook to generate a custom method body for the property setter. This version of the
 * hook is deprecated, users should use {@link #writeGetterBody(JavaFileWriter, MethodDeclarationParameters)}
 * instead.
 */
@Deprecated
protected void writeSetterBody(JavaFileWriter writer, String argName) throws IOException {
  writer.writeStatement(Expressions.callMethod("set", propertyName, argName));
  writer.writeStringStatement("return this");
}

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();
}

@Override
public final void emitSetter(JavaFileWriter writer) throws IOException {
  if (isDeprecated) {
    return;
  }
  MethodDeclarationParameters params = setterMethodParams();
  modelSpec.getPluginBundle().beforeEmitSetter(writer, this, params);
  writer.beginMethodDefinition(params);
  writeSetterBody(writer, params);
  writer.finishMethodDefinition();
  modelSpec.getPluginBundle().afterEmitSetter(writer, this, params);
}

/**
 * Subclasses can override this hook to generate a custom method body for the property getter. This version of the
 * hook is deprecated, users should use {@link #writeGetterBody(JavaFileWriter, MethodDeclarationParameters)}
 * instead.
 */
@Deprecated
protected void writeGetterBody(JavaFileWriter writer) throws IOException {
  writer.writeStatement(Expressions.callMethod("get", propertyName).returnExpr());
}

@Override
protected void writeGetterBody(JavaFileWriter writer, MethodDeclarationParameters params) throws IOException {
  final String value = "value";
  writer.writeFieldDeclaration(CoreTypes.JAVA_STRING, value,
      Expressions.callMethod("get", propertyName));
  Expression condition = Expressions.fromString(value + " == null");
  Expression ifTrue = Expressions.fromString("null");
  Expression ifFalse = Expressions.staticMethod(enumType, "valueOf", value);
  TernaryExpression ternary = new TernaryExpression(condition, ifTrue, ifFalse);
  writer.writeStatement(ternary.returnExpr());
}

@Override
protected void writeGetterBody(JavaFileWriter writer, MethodDeclarationParameters params) throws IOException {
  writer.writeStringStatement("return super.getRowId()");
}

private void beginClassDeclaration() throws IOException {
  if (modelSpec.getModelSpecElement().getAnnotation(Deprecated.class) != null) {
    writer.writeAnnotation(CoreTypes.DEPRECATED);
  }
  TypeDeclarationParameters params = new TypeDeclarationParameters()
      .setName(modelSpec.getGeneratedClassName())
      .setSuperclass(modelSpec.getModelSuperclass())
      .setInterfaces(accumulateInterfacesFromPlugins())
      .setKind(Type.CLASS)
      .setModifiers(Modifier.PUBLIC);
  writer.beginTypeDefinition(params);
}

protected void emitPropertyArrayInitialization() throws IOException {
  writer.beginInitializerBlock(true, true);
  writePropertiesInitializationBlock();
  writer.finishInitializerBlock(false, true);
}