How to use

writeNewline

method

in

com.yahoo.aptutils.writer.JavaFileWriter

private void emitUnaliasedPropertyArray() throws IOException {
  writer.writeComment("--- unaliased property references");
  Expression basePropertiesInit = Expressions.block(new Expression() {
    @Override
    public boolean writeExpression(JavaFileWriter writer) throws IOException {
      return emitPropertyReferenceArrayBody(false);
    }
  }, false, false, false, false);
  writer.writeFieldDeclaration(TypeConstants.PROPERTY_ARRAY, BASE_PROPERTY_ARRAY_NAME,
      basePropertiesInit, TypeConstants.PRIVATE_STATIC_FINAL)
      .writeNewline();
}

private void emitPropertyDeclarations() throws IOException {
  writer.writeComment("--- property declarations");
  emitAllProperties();
  emitPropertyArrayInitialization();
  writer.writeNewline();
}

protected void emitPropertiesArray() throws IOException {
  writer.writeComment("--- allocate properties array");
  writer.writeFieldDeclaration(TypeConstants.PROPERTY_ARRAY, PROPERTIES_ARRAY_NAME,
      Expressions.arrayAllocation(TypeConstants.PROPERTY, 1, getPropertiesArrayLength()),
      TypeConstants.PUBLIC_STATIC_FINAL);
  writer.writeNewline();
}

@Override
public void afterEmitSchema(JavaFileWriter writer) throws IOException {
  writer.writeComment("--- constants");
  for (VariableElement constant : constantElements) {
    writeConstantField(writer, modelSpec.getModelSpecName(), constant);
  }
  for (Map.Entry<String, List<VariableElement>> innerClassConstant : innerClassConstants.entrySet()) {
    String classNameString = innerClassConstant.getKey();
    DeclaredTypeName constClassName = new DeclaredTypeName(null,
        modelSpec.getModelSpecName().getSimpleName() + "." + classNameString);
    for (VariableElement element : innerClassConstant.getValue()) {
      writeConstantField(writer, constClassName, element);
    }
  }
  writer.writeNewline();
}

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

@Override
protected void emitAllProperties() throws IOException {
  for (PropertyGenerator generator : modelSpec.getPropertyGenerators()) {
    modelSpec.getPluginBundle().beforeEmitPropertyDeclaration(writer, generator);
    generator.emitPropertyDeclaration(writer);
    modelSpec.getPluginBundle().afterEmitPropertyDeclaration(writer, generator);
    writer.writeNewline();
  }
  for (PropertyGenerator deprecatedProperty : modelSpec.getDeprecatedPropertyGenerators()) {
    modelSpec.getPluginBundle().beforeEmitPropertyDeclaration(writer, deprecatedProperty);
    deprecatedProperty.emitPropertyDeclaration(writer);
    modelSpec.getPluginBundle().afterEmitPropertyDeclaration(writer, deprecatedProperty);
    writer.writeNewline();
  }
}

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

  @Override
  public void afterEmitMethods(JavaFileWriter writer) throws IOException {
    // emit creator for parcelable
    writer.writeComment("--- parcelable helpers");
    List<DeclaredTypeName> genericList = Collections.singletonList(modelSpec.getGeneratedClassName());
    DeclaredTypeName creatorType = TypeConstants.CREATOR.clone();
    DeclaredTypeName modelCreatorType = TypeConstants.MODEL_CREATOR.clone();
    creatorType.setTypeArgs(genericList);
    modelCreatorType.setTypeArgs(genericList);

    writer.writeFieldDeclaration(creatorType,
        "CREATOR", Expressions.callConstructor(modelCreatorType,
            Expressions.classObject(modelSpec.getGeneratedClassName())),
        TypeConstants.PUBLIC_STATIC_FINAL)
        .writeNewline();
  }
}

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

private void emitSqlTableDeclaration(boolean view) throws IOException {
  writer.writeComment("--- " + (view ? "view" : "subquery") + " declaration");
  String name = "\"" + modelSpec.getSpecAnnotation().viewName().trim() + "\"";
  if (modelSpec.getQueryElement() != null) {
    Expression queryReference = Expressions.staticReference(modelSpec.getModelSpecName(),
        modelSpec.getQueryElement().getSimpleName().toString())
        .callMethod("selectMore", ALIASED_PROPERTY_ARRAY_NAME);
    if (modelSpec.getViewQueryAnnotation().freeze()) {
      queryReference = queryReference.callMethod("freeze");
    }
    writer.writeFieldDeclaration(TypeConstants.QUERY, QUERY_NAME, queryReference,
        TypeConstants.PUBLIC_STATIC_FINAL);
    Expression initializer = constructInitializer(name, view);
    writer.writeFieldDeclaration(view ? TypeConstants.VIEW : TypeConstants.SUBQUERY_TABLE,
        view ? VIEW_NAME : SUBQUERY_NAME, initializer, TypeConstants.PUBLIC_STATIC_FINAL);
  } else {
    writer.writeFieldDeclaration(CoreTypes.JAVA_STRING, view ? "VIEW_NAME" : "SUBQUERY_NAME",
        Expressions.fromString(name), TypeConstants.PUBLIC_STATIC_FINAL);
  }
  writer.writeNewline();
}

private void emitSinglePropertyDeclaration(PropertyGenerator generator) throws IOException {
  modelSpec.getPluginBundle().beforeEmitPropertyDeclaration(writer, generator);
  writer.writeFieldDeclaration(generator.getPropertyType(), generator.getPropertyName(),
      Expressions.staticReference(modelSpec.getModelSpecName(), generator.getPropertyName()),
      TypeConstants.PUBLIC_STATIC_FINAL)
      .writeNewline();
  modelSpec.getPluginBundle().afterEmitPropertyDeclaration(writer, generator);
}

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

private void emitSinglePropertyDeclaration(PropertyGenerator generator, int index) throws IOException {
  modelSpec.getPluginBundle().beforeEmitPropertyDeclaration(writer, generator);
  DeclaredTypeName type = generator.getPropertyType();
  String fieldToQualify = ALIASED_PROPERTY_ARRAY_NAME + "[" + index + "]";
  Expression expressionToCast;
  if (modelSpec.getQueryElement() != null) {
    String callOn = modelSpec.getSpecAnnotation().isSubquery() ? SUBQUERY_NAME : VIEW_NAME;
    expressionToCast = Expressions.callMethodOn(callOn, "qualifyField", fieldToQualify);
  } else {
    expressionToCast = Expressions.reference(fieldToQualify);
  }
  writer.writeFieldDeclaration(type, generator.getPropertyName(),
      expressionToCast.cast(type), TypeConstants.PUBLIC_STATIC_FINAL)
      .writeNewline();
  modelSpec.getPluginBundle().afterEmitPropertyDeclaration(writer, generator);
}

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

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

private void emitUnaliasedPropertyArray() throws IOException {
  writer.writeComment("--- unaliased property references");
  Expression basePropertiesInit = Expressions.block(new Expression() {
    @Override
    public boolean writeExpression(JavaFileWriter writer) throws IOException {
      return emitPropertyReferenceArrayBody(false);
    }
  }, false, false, false, false);
  writer.writeFieldDeclaration(TypeConstants.PROPERTY_ARRAY, BASE_PROPERTY_ARRAY_NAME,
      basePropertiesInit, TypeConstants.PRIVATE_STATIC_FINAL)
      .writeNewline();
}

private void emitPropertyDeclarations() throws IOException {
  writer.writeComment("--- property declarations");
  emitAllProperties();
  emitPropertyArrayInitialization();
  writer.writeNewline();
}

protected void emitPropertiesArray() throws IOException {
  writer.writeComment("--- allocate properties array");
  writer.writeFieldDeclaration(TypeConstants.PROPERTY_ARRAY, PROPERTIES_ARRAY_NAME,
      Expressions.arrayAllocation(TypeConstants.PROPERTY, 1, getPropertiesArrayLength()),
      TypeConstants.PUBLIC_STATIC_FINAL);
  writer.writeNewline();
}

private void emitSinglePropertyDeclaration(PropertyGenerator generator) throws IOException {
  modelSpec.getPluginBundle().beforeEmitPropertyDeclaration(writer, generator);
  writer.writeFieldDeclaration(generator.getPropertyType(), generator.getPropertyName(),
      Expressions.staticReference(modelSpec.getModelSpecName(), generator.getPropertyName()),
      TypeConstants.PUBLIC_STATIC_FINAL)
      .writeNewline();
  modelSpec.getPluginBundle().afterEmitPropertyDeclaration(writer, generator);
}