Java Code Examples for com.squareup.javawriter.JavaWriter#endMethod()

private void writeWriteToParcelMethod(JavaWriter writer) throws IOException {
    List<String> parameters = new ArrayList<>(4);
    parameters.add(elementCompressedName);
    parameters.add("object");
    parameters.add("Parcel");
    parameters.add("dest");

    writer.emitAnnotation(Override.class);
    writer.beginMethod("void", "writeToParcel", Modifiers.PUBLIC, parameters, null);
    writer.emitStatement("Bundle bundle = new Bundle()");

    for (VariableElement field : parceledFields) {
        getSaveStatementWriter(field).writeFieldWriteStatement(field, writer);
    }

    writer.emitStatement("dest.writeBundle(bundle)");
    writer.endMethod();
}
 

private void writeReadFromParcelMethod(JavaWriter writer) throws IOException {
    writer.emitAnnotation(Override.class);
    writer.beginMethod(elementCompressedName, "readFromParcel", Modifiers.PUBLIC, "Parcel",
                       "parcel");

    writer.emitStatement("%s object = new %s()", elementCompressedName, elementCompressedName);
    writer.emitStatement("Bundle bundle = parcel.readBundle()");
    writer.emitStatement("bundle.setClassLoader(%s.class.getClassLoader())",
                         elementCompressedName);
    for (VariableElement field : parceledFields) {
        getSaveStatementWriter(field).writeFieldReadStatement(field,
                                                              postCreateChildMethods,
                                                              writer);
    }
    writer.emitStatement("return object");
    writer.endMethod();
}
 

private static void writeSetterFunc(JavaWriter writer, SettingInfo setting)
        throws IOException {
    Object setterNameObj = setting.properties.get("setter");
    String setterName = setterNameObj instanceof String
            ? (String) setting.properties.get("setter") : null;
    if (setterName == null)
        setterName = "set" + capitalize(setting.name);

    writer.beginMethod("void", setterName,
            EnumSet.of(Modifier.PUBLIC, Modifier.STATIC), setting.type, "value");

    switch (setting.type) {
        case "boolean":
            writeSimpleSetterFuncBody(writer, "putBoolean", setting.staticMemberName);
            break;
        case "int":
            writeSimpleSetterFuncBody(writer, "putInt", setting.staticMemberName);
            break;
        case "String":
            writeSimpleSetterFuncBody(writer, "putString", setting.staticMemberName);
            break;
        case "long":
            writeSimpleSetterFuncBody(writer, "putLong", setting.staticMemberName);
            break;
        default:
            throw new IllegalArgumentException("Type not supported: " + setting.type);
    }

    writer.endMethod();
}
 

private void emitReaderMethod(Set<? extends Element> elements, Element hostActivity, JavaWriter writer) throws IOException {
    writer.emitEmptyLine();
    writer.emitAnnotation(Override.class);
    writer.beginMethod("void", "retain", EnumSet.of(Modifier.PUBLIC), "Activity", "source");
    final String activityClass = hostActivity.getSimpleName().toString();
    writer.emitStatement(activityClass + " activity = (" + activityClass + ") source");
    for (Element element : elements) {
        writer.emitStatement("this." + element.getSimpleName() + " = activity." + element.getSimpleName());
    }
    writer.endMethod();
}
 

private void emitWriterMethod(Set<? extends Element> elements, Element hostActivity, JavaWriter writer) throws IOException {
    writer.emitEmptyLine();
    writer.emitAnnotation(Override.class);
    writer.beginMethod("void", "restore", EnumSet.of(Modifier.PUBLIC), "Activity", "target");
    final String activityClass = hostActivity.getSimpleName().toString();
    writer.emitStatement(activityClass + " activity = (" + activityClass + ") target");
    for (Element element : elements) {
        writer.emitStatement("activity." + element.getSimpleName() + " = this." + element.getSimpleName());
    }
    writer.endMethod();
}
 

private void writeGetModelAdapter(JavaWriter writer) throws IOException {
	writer.beginMethod("<T extends Model> ModelAdapter<T>", "getModelAdapter", METHOD_MODIFIERS,
			"Class<? extends Model>", "cls");
	writer.emitStatement("return MODEL_ADAPTERS.get(cls)");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void writeDelete(JavaWriter writer, String modelQualifiedName, String tableName) throws IOException {
	writer.beginMethod("void", "delete", MODIFIERS, modelQualifiedName, "entity", "SQLiteDatabase", "db");
	writer.emitStatement("db.delete(\"" + tableName + "\", \"" + Model._ID
			+ "=?\", new String[]{entity.id.toString()})");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void writeSave(JavaWriter writer, String modelQualifiedName, Set<ColumnElement> columns) throws
		IOException {

	writer.beginMethod("Long", "save", MODIFIERS, modelQualifiedName, "entity", "SQLiteDatabase", "db");
	writer.emitStatement("ContentValues values = new ContentValues()");

	for (ColumnElement column : columns) {
		final StringBuilder value = new StringBuilder();
		int closeParens = 0;

		if (!column.isModel() && column.requiresTypeAdapter()) {
			closeParens++;
			value.append("(").append(column.getSerializedQualifiedName())
					.append(") Ollie.getTypeAdapter(")
					.append(column.getDeserializedQualifiedName())
					.append(".class).serialize(");
		}

		value.append("entity.").append(column.getFieldName());

		if (column.isModel()) {
			value.append(" != null ? ");
			value.append("entity.").append(column.getFieldName()).append(".id");
			value.append(" : null");
		}

		for (int i = 0; i < closeParens; i++) {
			value.append(")");
		}

		writer.emitStatement("values.put(\"" + column.getColumnName() + "\", " + value.toString() + ")");
	}

	writer.emitStatement("return insertOrUpdate(entity, db, values)");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

/** Creates the function for updating an object */
private void emitUpdate(JavaWriter javaWriter) throws IOException {
  logger.d("emitUpdate");
  javaWriter.beginMethod("void", $$UPDATE_OBJECT_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      getTargetClass(), "element", "SQLiteDatabase", "db")
      .emitStatement("ContentValues values = new ContentValues()");

  for (TableColumn column : columns) {
    String columnName = column.getColumnName();
    String memberName = column.getMemberName();
    if (column.getSqlType() == SqliteType.BLOB && !column.isByteArray()) {
      javaWriter.emitStatement("values.put(\"%s\", %s(element.%s))", columnName,
          SERIALIZE_FUNCTION, memberName);
    } else if (column.isOneToOne()) {
      javaWriter.emitStatement("values.put(\"%s\", %s%s.%s(element.%s))", columnName,
          column.getType(), $$SUFFIX, GET_ID_FUNCTION, memberName);
    } else if (column.isDate()) {
      javaWriter.emitStatement("values.put(\"%s\", element.%s.getTime())", columnName,
          memberName);
    } else if (column.isOneToMany()) {
      javaWriter.beginControlFlow("for (%s child : element.%s)",
          column.getType().replace("$", "."), column.getColumnName())
          .emitStatement("%s%s.%s(child, db)", column.getType(), $$SUFFIX,
              $$UPDATE_OBJECT_FUNCTION)
          .endControlFlow();
    } else if (column.isOneToManyChild()) {
      // TODO: actually no way of actually updating this value directly add a wrapper?
    } else {
      javaWriter.emitStatement("values.put(\"%s\", element.%s)", columnName, memberName);
    }
  }
  javaWriter.emitStatement("db.update(\"%s\", values, \"%s = \" + element.%s, null)",
      getTableName(), idColumn.getColumnName(), idColumn.getMemberName());
  javaWriter.endMethod();
}
 

private void writeNewArrayMethod(JavaWriter writer) throws IOException {
    writer.emitAnnotation(Override.class);
    writer.beginMethod(String.format("%s[]", elementCompressedName),
                       "newArray",
                       Modifiers.PUBLIC,
                       "int",
                       "size");
    writer.emitStatement("return new %s[size]", elementCompressedName);
    writer.endMethod();
}
 

private static void writeGetterFunc(JavaWriter writer, SettingInfo setting) throws IOException {
    String getterName = (String) setting.properties.get("getter");
    if (getterName == null)
        getterName = getGetterPrefix(setting.type) + capitalize(setting.name);

    writer.beginMethod(setting.type, getterName, EnumSet.of(Modifier.PUBLIC, Modifier.STATIC));

    switch (setting.type) {
        case "boolean":
            writeSimpleGetterFuncBody(writer, "getBoolean",
                    setting.staticMemberName, setting.defaultValue);
            break;
        case "int":
            writeSimpleGetterFuncBody(writer, "getInt",
                    setting.staticMemberName, setting.defaultValue);
            break;
        case "String":
            writeSimpleGetterFuncBody(writer, "getString",
                    setting.staticMemberName, setting.defaultValue);
            break;
        case "String[]":
            writeStringArrGetterFuncBody(writer, setting.staticMemberName,
                    setting.defaultValue, setting.properties);
            break;
        case "long":
            writer.emitStatement(
                    "return SettingsHelper.getLong(getPreferences(), %s, %s)",
                    setting.staticMemberName, setting.defaultValue);
            break;
        default:
            throw new IllegalArgumentException("Type not supported: " + setting.type);
    }

    writer.endMethod();
}
 

private void writeGetModelType(JavaWriter writer, String modelSimpleName) throws IOException {
	writer.beginMethod("Class<? extends Model>", "getModelType", MODIFIERS);
	writer.emitStatement("return " + modelSimpleName + ".class");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void writeGetTableName(JavaWriter writer, String tableName) throws IOException {
	writer.beginMethod("String", "getTableName", MODIFIERS);
	writer.emitStatement("return \"" + tableName + "\"");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

/** Creates the function for inserting a new value into the database */
private void emitInsert(JavaWriter javaWriter) throws IOException {
  logger.d("emitInsert");
  String tableName = getTableName();
  javaWriter.beginMethod("void", $$INSERT_OBJECT_FUNCTION, EnumSet.of(PUBLIC, STATIC),
      getTargetClass(), "element", "SQLiteDatabase", "db")
      .emitStatement("ContentValues values = new ContentValues()");
  List<TableColumn> childColumns = Lists.newLinkedList();
  for (TableColumn column : columns) {
    String columnName = column.getColumnName();
    String memberName = column.getMemberName();
    if (column.isBlob() && !column.isByteArray()) {
      javaWriter.emitStatement("values.put(\"%s\", %s(element.%s))", columnName,
          SERIALIZE_FUNCTION, memberName);
    } else if (column.isOneToOne()) {
      javaWriter.emitStatement("%s%s.%s(element.%s, db)", column.getType(), $$SUFFIX,
          INSERT_ONE_TO_ONE, column.getColumnName())
          .emitStatement("values.put(\"%s\", %s%s.%s(element.%s))", columnName, column.getType(),
              $$SUFFIX, GET_ID_FUNCTION, memberName);
    } else if (column.isDate()) {
      javaWriter.emitStatement("values.put(\"%s\", element.%s.getTime())", columnName,
          memberName);
    } else if (column.isOneToMany()) {
      childColumns.add(column);
    } else if (!column.isOneToManyChild()) {
      javaWriter.emitStatement("values.put(\"%s\", element.%s)", columnName, memberName);
    }
  }
  javaWriter.emitStatement("db.insert(\"%s\", null, values)", tableName);

  if (!childColumns.isEmpty()) {
    javaWriter.emitStatement("long id = DatabaseUtils.longForQuery(db, "
        + "\"SELECT ROWID FROM %s ORDER BY ROWID DESC LIMIT 1\", null)", tableName);
  }
  for (TableColumn childColumn : childColumns) {
    javaWriter.emitStatement("%s%s.%s(id, element.%s, db)", childColumn.getType(), $$SUFFIX,
        PARENT_INSERT_FUNCTION, childColumn.getMemberName());
  }

  javaWriter.endMethod();
}
 

private static void writeAbstractPhraseClass(JavaWriter writer) throws IOException {
  writer.beginType(ABSTRACT_PHRASE_CLASS, "class", EnumSet.of(PUBLIC, STATIC, ABSTRACT));

  writer.emitField("int", "resId", EnumSet.of(PRIVATE, FINAL));
  writer.emitField("String[]", "keys", EnumSet.of(PRIVATE, FINAL));
  writer.emitField("CharSequence[]", "values", EnumSet.of(FINAL));
  writer.emitEmptyLine();

  writer.beginConstructor(EnumSet.of(PRIVATE), "int", "resId", "String...", "keys");
  writer.emitStatement("this.resId = resId");
  writer.emitStatement("this.keys = keys");
  writer.emitStatement("this.values = new String[keys.length]");
  writer.endConstructor();
  writer.emitEmptyLine();

  writer.emitAnnotation(SuppressWarnings.class, "\"ConstantConditions\"");
  writer.beginMethod("CharSequence", "build", EnumSet.of(PUBLIC, FINAL), "View", "view");
  writer.emitStatement("return build(view.getContext().getResources())");
  writer.endMethod();
  writer.emitEmptyLine();

  writer.beginMethod("CharSequence", "build", EnumSet.of(PUBLIC, FINAL), "Context", "context");
  writer.emitStatement("return build(context.getResources())");
  writer.endMethod();
  writer.emitEmptyLine();

  writer.beginMethod("CharSequence", "build", EnumSet.of(PUBLIC, FINAL), "Resources", "res");
  writer.emitStatement(
      "SpannableStringBuilder text = new SpannableStringBuilder(res.getText(resId))");
  writer.emitStatement("int token = 0");
  writer.beginControlFlow("while ((token = nextToken(text, token)) != -1)");
  writer.emitStatement("String key = tokenAt(text, token)");
  writer.beginControlFlow("if (key == null)");
  writer.emitSingleLineComment("Skip this and next character to avoid '{{' instances.");
  writer.emitStatement("token += 2");
  writer.emitStatement("continue");
  writer.endControlFlow();
  writer.emitStatement("int index = Arrays.binarySearch(keys, key)");
  writer.beginControlFlow("if (index < 0)");
  writer.emitStatement(
      "throw new AssertionError(\"Unknown key '\" + key + \"' in: \" + Arrays.toString(keys))");
  writer.endControlFlow();
  writer.emitStatement("CharSequence value = values[index]");
  writer.emitStatement("text.replace(token, token + key.length() + 2, value)");
  writer.emitStatement("token += value.length()");
  writer.endControlFlow();
  writer.emitStatement("return text");
  writer.endMethod();
  writer.emitEmptyLine();

  writer.beginMethod("int", "nextToken", EnumSet.of(PRIVATE, STATIC), "SpannableStringBuilder",
      "b", "int", "start");
  writer.beginControlFlow("for (int i = start + 1, end = b.length(); i < end; i++)");
  writer.beginControlFlow("if (b.charAt(i) == '{')");
  writer.emitStatement("return i");
  writer.endControlFlow();
  writer.endControlFlow();
  writer.emitStatement("return -1");
  writer.endMethod();
  writer.emitEmptyLine();

  writer.beginMethod("String", "tokenAt", EnumSet.of(PRIVATE, STATIC), "SpannableStringBuilder",
      "b", "int", "start");
  writer.beginControlFlow("for (int i = start + 1, end = b.length(); i < end; i++)");
  writer.emitStatement("char current = b.charAt(i)");
  writer.beginControlFlow("if (current == '}')");
  writer.emitStatement("return b.subSequence(start + 1, i).toString()");
  writer.endControlFlow();
  writer.beginControlFlow("if (current < 'a' || current > 'z')");
  writer.emitStatement("break");
  writer.endControlFlow();
  writer.endControlFlow();
  writer.emitStatement("return null");
  writer.endMethod();

  writer.endType();
}
 

private void writeGetMigrations(JavaWriter writer) throws IOException {
	writer.beginMethod("List<? extends Migration>", "getMigrations", METHOD_MODIFIERS);
	writer.emitStatement("return MIGRATIONS");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void writeGetModelAdapters(JavaWriter writer) throws IOException {
	writer.beginMethod("List<? extends ModelAdapter>", "getModelAdapters", METHOD_MODIFIERS);
	writer.emitStatement("return new ArrayList(MODEL_ADAPTERS.values())");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

private void writeGetTypeAdpater(JavaWriter writer) throws IOException {
	writer.beginMethod("<D, S> TypeAdapter<D, S>", "getTypeAdapter", METHOD_MODIFIERS, "Class<D>", "cls");
	writer.emitStatement("return TYPE_ADAPTERS.get(cls)");
	writer.endMethod();
}
 

public static void generate(File outputFile, String packageName, String className, String key,
                            String implementation) throws IOException {
    File outputDir = outputFile.getParentFile();
    if (!outputDir.exists() && !outputDir.mkdirs()) {
        throw new IOException("Can not mkdirs the dir: " + outputDir);
    }

    int lastIndexOfDot = implementation.lastIndexOf(".");
    String implementationSimpleClassName = lastIndexOfDot == -1 ? implementation :
            implementation.substring(implementation.lastIndexOf(".") + 1);

    JavaWriter javaWriter = new JavaWriter(new FileWriter(outputFile));
    javaWriter.emitPackage(packageName);
    javaWriter.emitEmptyLine();
    javaWriter.emitImports(implementation);
    javaWriter.emitEmptyLine();

    javaWriter.emitJavadoc("Generated code from StringFog gradle plugin. Do not modify!");
    javaWriter.beginType(className, "class", ImmutableSet.of(Modifier.PUBLIC,
            Modifier.FINAL));

    javaWriter.emitField(implementationSimpleClassName, "IMPL",
            ImmutableSet.of(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL),
            "new " + implementationSimpleClassName + "()");

    javaWriter.emitEmptyLine();
    javaWriter.beginMethod(String.class.getSimpleName(), "encrypt",
            ImmutableSet.of(Modifier.PUBLIC, Modifier.STATIC),
            String.class.getSimpleName(), "value");
    javaWriter.emitStatement("return " + "IMPL.encrypt(value, \"" + key + "\")");
    javaWriter.endMethod();

    javaWriter.emitEmptyLine();
    javaWriter.beginMethod(String.class.getSimpleName(), "decrypt",
            ImmutableSet.of(Modifier.PUBLIC, Modifier.STATIC),
            String.class.getSimpleName(), "value");
    javaWriter.emitStatement("return " + "IMPL.decrypt(value, \"" + key + "\")");
    javaWriter.endMethod();

    javaWriter.emitEmptyLine();
    javaWriter.beginMethod(boolean.class.getSimpleName(), "overflow",
            ImmutableSet.of(Modifier.PUBLIC, Modifier.STATIC),
            String.class.getSimpleName(), "value");
    javaWriter.emitStatement("return " + "IMPL.overflow(value, \"" + key + "\")");
    javaWriter.endMethod();

    javaWriter.emitEmptyLine();
    javaWriter.endType();

    javaWriter.close();
}