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

public void generateParceler() throws IOException {

        JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(parcelerName);
        JavaWriter writer = new JavaWriter(sourceFile.openWriter());

        writer.emitPackage(processingEnv.getElementUtils().getPackageOf(
                elementToParcel).getQualifiedName().toString());

        writer.emitImports(getImports());
        writer.emitEmptyLine();
        elementCompressedName = writer.compressType(elementToParcel.getQualifiedName().toString());
        writer.beginType(parcelerName, "class", EnumSet.of(Modifier.PUBLIC, Modifier.FINAL), null,
                         JavaWriter.type(Parceler.class, elementCompressedName));
        writer.emitEmptyLine();

        writeWriteToParcelMethod(writer);
        writer.emitEmptyLine();
        writeReadFromParcelMethod(writer);
        writer.emitEmptyLine();
        writeNewArrayMethod(writer);
        writer.emitEmptyLine();

        writer.endType();
        writer.close();
    }
 

private void writeCollections(JavaWriter writer) throws IOException {
	writer.emitField(
			"List<Migration>",
			"MIGRATIONS",
			CONSTANT_MODIFIERS,
			"new ArrayList<Migration>()"
	);
	writer.emitField(
			"Map<Class<? extends Model>, ModelAdapter>",
			"MODEL_ADAPTERS",
			CONSTANT_MODIFIERS,
			"new HashMap<Class<? extends Model>, ModelAdapter>()"
	);
	writer.emitField(
			"Map<Class, TypeAdapter>",
			"TYPE_ADAPTERS",
			CONSTANT_MODIFIERS,
			"new HashMap<Class, TypeAdapter>()"
	);
	writer.emitEmptyLine();
}
 

private void writeStaticInitializations(JavaWriter writer) throws IOException {
	writer.beginInitializer(true);

	List<MigrationElement> migrations = Lists.newArrayList(registry.getMigrationElements());
	if (!migrations.isEmpty()) {
		Collections.sort(migrations);
		for (MigrationElement migration : migrations) {
			writer.emitStatement("MIGRATIONS.add(new %s())",
					migration.getQualifiedName());
		}
		writer.emitEmptyLine();
	}

	List<ModelAdapterElement> modelAdapters = Lists.newArrayList(registry.getModelAdapterElements());
	if (!modelAdapters.isEmpty()) {
		Collections.sort(modelAdapters);
		for (ModelAdapterElement modelAdapter : modelAdapters) {
			writer.emitStatement("MODEL_ADAPTERS.put(%s.class, new %s())",
					modelAdapter.getModelQualifiedName(),
					modelAdapter.getQualifiedName());
		}
		writer.emitEmptyLine();
	}

	List<TypeAdapterElement> typeAdapters = Lists.newArrayList(registry.getTypeAdapterElements());
	if (!typeAdapters.isEmpty()) {
		Collections.sort(typeAdapters);
		for (TypeAdapterElement typeAdapter : typeAdapters) {
			writer.emitStatement("TYPE_ADAPTERS.put(%s.class, new %s())",
					typeAdapter.getDeserializedQualifiedName(),
					typeAdapter.getQualifiedName());
		}
	}

	writer.endInitializer();
	writer.emitEmptyLine();
}
 

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 emitClassHeader(PackageElement packageElement, TypeElement activityType, JavaWriter writer) throws IOException {
    writer.emitPackage(packageElement.getQualifiedName().toString());

    if (isFragmentActivity(activityType)) {
        writer.emitImports("android.support.v4.app.Fragment");
    } else {
        writer.emitImports("android.app.Fragment");
    }
    writer.emitImports("android.app.Activity");
    writer.emitEmptyLine();
}
 

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 writeImports(JavaWriter writer) throws IOException {
	Set<String> imports = Sets.newHashSet(
			ArrayList.class.getName(),
			HashMap.class.getName(),
			List.class.getName(),
			Map.class.getName(),
			AdapterHolder.class.getName(),
			ModelAdapter.class.getName()
	);

	writer.emitImports(imports);
	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();
}
 

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

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 writeGetTableName(JavaWriter writer, String tableName) throws IOException {
	writer.beginMethod("String", "getTableName", MODIFIERS);
	writer.emitStatement("return \"" + tableName + "\"");
	writer.endMethod();
	writer.emitEmptyLine();
}
 

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 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 emitConstructor(String simpleClassName, JavaWriter writer) throws IOException {
    writer.emitEmptyLine();
    writer.beginMethod(null, simpleClassName, EnumSet.of(Modifier.PUBLIC))
            .emitStatement("setRetainInstance(true)")
            .endMethod();
}
 

private void emitFields(Set<? extends Element> elements, JavaWriter writer) throws IOException {
    writer.emitEmptyLine();
    for (Element element : elements) {
        writer.emitField(element.asType().toString(), element.getSimpleName().toString());
    }
}