void emit(CodeWriter codeWriter, Set<Modifier> implicitModifiers) throws IOException { codeWriter.emitJavadoc(javadoc); codeWriter.emitAnnotations(annotations, false); codeWriter.emitModifiers(modifiers, implicitModifiers); codeWriter.emit("$T $L", type, name); if (!initializer.isEmpty()) { codeWriter.emit(" = "); codeWriter.emit(initializer); } codeWriter.emit(";\n"); }
/** * Emit type variables with their bounds. This should only be used when declaring type variables; * everywhere else bounds are omitted. */ public void emitTypeVariables(List<TypeVariableName> typeVariables) throws IOException { if (typeVariables.isEmpty()) return; typeVariables.forEach(typeVariable -> currentTypeVariables.add(typeVariable.name)); emit("<"); boolean firstTypeVariable = true; for (TypeVariableName typeVariable : typeVariables) { if (!firstTypeVariable) emit(", "); emitAnnotations(typeVariable.annotations, true); emit("$L", typeVariable.name); boolean firstBound = true; for (TypeName bound : typeVariable.bounds) { emit(firstBound ? " extends $T" : " & $T", bound); firstBound = false; } firstTypeVariable = false; } emit(">"); }
codeWriter.emit(" "); codeWriter.emit("$L($Z", enclosingName); } else { codeWriter.emit("$T $L($Z", returnType, name); for (Iterator<ParameterSpec> i = parameters.iterator(); i.hasNext(); ) { ParameterSpec parameter = i.next(); if (!firstParameter) codeWriter.emit(",").emitWrappingSpace(); parameter.emit(codeWriter, !i.hasNext() && varargs); firstParameter = false; codeWriter.emit(")"); codeWriter.emit(" default "); codeWriter.emit(defaultValue); codeWriter.emitWrappingSpace().emit("throws"); boolean firstException = true; for (TypeName exception : exceptions) { if (!firstException) codeWriter.emit(","); codeWriter.emitWrappingSpace().emit("$T", exception); firstException = false; codeWriter.emit(";\n"); } else if (hasModifier(Modifier.NATIVE)) { codeWriter.emit(code); codeWriter.emit(";\n");
CodeWriter emit(CodeWriter out) throws IOException { if (keyword == null) throw new AssertionError(); if (isAnnotated()) { out.emit(""); emitAnnotations(out); } return out.emitAndIndent(keyword); }
void emit(CodeWriter codeWriter, boolean varargs) throws IOException { codeWriter.emitAnnotations(annotations, true); codeWriter.emitModifiers(modifiers); if (varargs) { TypeName.asArray(type).emit(codeWriter, true); } else { type.emit(codeWriter); } codeWriter.emit(" $L", name); }
private void emit(CodeWriter codeWriter) throws IOException { codeWriter.pushPackage(packageName); if (!fileComment.isEmpty()) { codeWriter.emitComment(fileComment); } if (!packageName.isEmpty()) { codeWriter.emit("package $L;\n", packageName); codeWriter.emit("\n"); } if (!staticImports.isEmpty()) { for (String signature : staticImports) { codeWriter.emit("import static $L;\n", signature); } codeWriter.emit("\n"); } int importedTypesCount = 0; for (ClassName className : new TreeSet<>(codeWriter.importedTypes().values())) { if (skipJavaLangImports && className.packageName().equals("java.lang")) continue; codeWriter.emit("import $L;\n", className.withoutAnnotations()); importedTypesCount++; } if (importedTypesCount > 0) { codeWriter.emit("\n"); } typeSpec.emit(codeWriter, null, Collections.emptySet()); codeWriter.popPackage(); }
private void emitLiteral(Object o) throws IOException { if (o instanceof TypeSpec) { TypeSpec typeSpec = (TypeSpec) o; typeSpec.emit(this, null, Collections.emptySet()); } else if (o instanceof AnnotationSpec) { AnnotationSpec annotationSpec = (AnnotationSpec) o; annotationSpec.emit(this, true); } else if (o instanceof CodeBlock) { CodeBlock codeBlock = (CodeBlock) o; emit(codeBlock); } else { emitAndIndent(String.valueOf(o)); } }
@Override CodeWriter emit(CodeWriter out) throws IOException { if (enclosingType != null) { enclosingType.emit(out); out.emit("."); if (isAnnotated()) { out.emit(" "); emitAnnotations(out); } out.emit(rawType.simpleName()); } else { rawType.emit(out); } if (!typeArguments.isEmpty()) { out.emitAndIndent("<"); boolean firstParameter = true; for (TypeName parameter : typeArguments) { if (!firstParameter) out.emitAndIndent(", "); parameter.emit(out); firstParameter = false; } out.emitAndIndent(">"); } return out; }
CodeWriter emitAnnotations(CodeWriter out) throws IOException { for (AnnotationSpec annotation : annotations) { annotation.emit(out, true); out.emit(" "); } return out; }
@Override public String toString() { StringBuilder out = new StringBuilder(); try { new CodeWriter(out).emit(this); return out.toString(); } catch (IOException e) { throw new AssertionError(); } }
public void emitAnnotations(List<AnnotationSpec> annotations, boolean inline) throws IOException { for (AnnotationSpec annotationSpec : annotations) { annotationSpec.emit(this, inline); emit(inline ? " " : "\n"); } }
@Override public String toString() { StringBuilder out = new StringBuilder(); try { CodeWriter codeWriter = new CodeWriter(out); codeWriter.emit("$L", this); return out.toString(); } catch (IOException e) { throw new AssertionError(); } }
public CodeWriter emit(String format, Object... args) throws IOException { return emit(CodeBlock.of(format, args)); }
private void emitAnnotationValues(CodeWriter codeWriter, String whitespace, String memberSeparator, List<CodeBlock> values) throws IOException { if (values.size() == 1) { codeWriter.indent(2); codeWriter.emit(values.get(0)); codeWriter.unindent(2); return; } codeWriter.emit("{" + whitespace); codeWriter.indent(2); boolean first = true; for (CodeBlock codeBlock : values) { if (!first) codeWriter.emit(memberSeparator); codeWriter.emit(codeBlock); first = false; } codeWriter.unindent(2); codeWriter.emit(whitespace + "}"); }
private CodeWriter emitBrackets(CodeWriter out, boolean varargs) throws IOException { if (isAnnotated()) { out.emit(" "); emitAnnotations(out); } if (TypeName.asArray(componentType) == null) { // Last bracket. return out.emit(varargs ? "..." : "[]"); } out.emit("[]"); return TypeName.asArray(componentType) .emitBrackets(out, varargs); }
if (members.isEmpty()) { codeWriter.emit("@$T", type); } else if (members.size() == 1 && members.containsKey("value")) { codeWriter.emit("@$T(", type); emitAnnotationValues(codeWriter, whitespace, memberSeparator, members.get("value")); codeWriter.emit(")"); } else { codeWriter.emit("@$T(" + whitespace, type); codeWriter.indent(2); for (Iterator<Map.Entry<String, List<CodeBlock>>> i = members.entrySet().iterator(); i.hasNext(); ) { Map.Entry<String, List<CodeBlock>> entry = i.next(); codeWriter.emit("$L = ", entry.getKey()); emitAnnotationValues(codeWriter, whitespace, memberSeparator, entry.getValue()); if (i.hasNext()) codeWriter.emit(memberSeparator); codeWriter.emit(whitespace + ")");