use of org.springframework.roo.classpath.details.comments.JavadocComment in project spring-roo by spring-projects.
the class JpaUnitTestMetadata method getCleanMethod.
/**
* Obtains a method annotated with @After for doing the test class teardown phase
* after finishing each test.
*
* @return {@link MethodMetadataBuilder}
*/
private MethodMetadataBuilder getCleanMethod() {
final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
bodyBuilder.newLine();
bodyBuilder.appendFormalLine("// Clean needed after executing each test method");
bodyBuilder.appendFormalLine("// To be implemented by developer");
bodyBuilder.newLine();
// Use the MethodMetadataBuilder for easy creation of MethodMetadata
MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, new JavaSymbolName("clean"), JavaType.VOID_PRIMITIVE, bodyBuilder);
// Add @After
methodBuilder.addAnnotation(new AnnotationMetadataBuilder(AFTER).build());
// Add comment
CommentStructure comment = new CommentStructure();
JavadocComment javaDocComment = new JavadocComment("This method will be automatically executed after each test method for freeing resources allocated with @Before annotated method.");
comment.addComment(javaDocComment, CommentLocation.BEGINNING);
methodBuilder.setCommentStructure(comment);
return methodBuilder;
}
use of org.springframework.roo.classpath.details.comments.JavadocComment in project spring-roo by spring-projects.
the class JavaParserConstructorMetadataBuilder method addConstructor.
// TODO: Should parse the throws types from JavaParser source
public static void addConstructor(final CompilationUnitServices compilationUnitServices, final List<BodyDeclaration> members, final ConstructorMetadata constructor, final Set<JavaSymbolName> typeParameters) {
Validate.notNull(compilationUnitServices, "Compilation unit services required");
Validate.notNull(members, "Members required");
Validate.notNull(constructor, "Method required");
// Start with the basic constructor
final ConstructorDeclaration d = new ConstructorDeclaration();
d.setModifiers(JavaParserUtils.getJavaParserModifier(constructor.getModifier()));
d.setName(PhysicalTypeIdentifier.getJavaType(constructor.getDeclaredByMetadataId()).getSimpleTypeName());
// Add any constructor-level annotations (not parameter annotations)
final List<AnnotationExpr> annotations = new ArrayList<AnnotationExpr>();
d.setAnnotations(annotations);
for (final AnnotationMetadata annotation : constructor.getAnnotations()) {
JavaParserAnnotationMetadataBuilder.addAnnotationToList(compilationUnitServices, annotations, annotation);
}
// Add any constructor parameters, including their individual
// annotations and type parameters
final List<Parameter> parameters = new ArrayList<Parameter>();
d.setParameters(parameters);
int index = -1;
for (final AnnotatedJavaType constructorParameter : constructor.getParameterTypes()) {
index++;
// Add the parameter annotations applicable for this parameter type
final List<AnnotationExpr> parameterAnnotations = new ArrayList<AnnotationExpr>();
for (final AnnotationMetadata parameterAnnotation : constructorParameter.getAnnotations()) {
JavaParserAnnotationMetadataBuilder.addAnnotationToList(compilationUnitServices, parameterAnnotations, parameterAnnotation);
}
// Compute the parameter name
final String parameterName = constructor.getParameterNames().get(index).getSymbolName();
// Compute the parameter type
Type parameterType = null;
if (constructorParameter.getJavaType().isPrimitive()) {
parameterType = JavaParserUtils.getType(constructorParameter.getJavaType());
} else {
final Type finalType = JavaParserUtils.getResolvedName(constructorParameter.getJavaType(), constructorParameter.getJavaType(), compilationUnitServices);
final ClassOrInterfaceType cit = JavaParserUtils.getClassOrInterfaceType(finalType);
// Add any type arguments presented for the return type
if (constructorParameter.getJavaType().getParameters().size() > 0) {
final List<Type> typeArgs = new ArrayList<Type>();
cit.setTypeArgs(typeArgs);
for (final JavaType parameter : constructorParameter.getJavaType().getParameters()) {
// NameExpr importedParameterType =
// JavaParserUtils.importTypeIfRequired(compilationUnitServices.getEnclosingTypeName(),
// compilationUnitServices.getImports(), parameter);
// typeArgs.add(JavaParserUtils.getReferenceType(importedParameterType));
typeArgs.add(JavaParserUtils.importParametersForType(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), parameter));
}
}
parameterType = finalType;
}
// Create a Java Parser constructor parameter and add it to the list
// of parameters
final Parameter p = new Parameter(parameterType, new VariableDeclaratorId(parameterName));
p.setAnnotations(parameterAnnotations);
parameters.add(p);
}
// Set the body
if (constructor.getBody() == null || constructor.getBody().length() == 0) {
d.setBlock(new BlockStmt());
} else {
// There is a body.
// We need to make a fake constructor that we can have JavaParser
// parse.
// Easiest way to do that is to build a simple source class
// containing the required method and re-parse it.
final StringBuilder sb = new StringBuilder();
sb.append("class TemporaryClass {\n");
sb.append(" TemporaryClass() {\n");
sb.append(constructor.getBody());
sb.append("\n");
sb.append(" }\n");
sb.append("}\n");
final ByteArrayInputStream bais = new ByteArrayInputStream(sb.toString().getBytes());
CompilationUnit ci;
try {
ci = JavaParser.parse(bais);
} catch (final IOException e) {
throw new IllegalStateException("Illegal state: Unable to parse input stream", e);
} catch (final ParseException pe) {
throw new IllegalStateException("Illegal state: JavaParser did not parse correctly", pe);
}
final List<TypeDeclaration> types = ci.getTypes();
if (types == null || types.size() != 1) {
throw new IllegalArgumentException("Method body invalid");
}
final TypeDeclaration td = types.get(0);
final List<BodyDeclaration> bodyDeclarations = td.getMembers();
if (bodyDeclarations == null || bodyDeclarations.size() != 1) {
throw new IllegalStateException("Illegal state: JavaParser did not return body declarations correctly");
}
final BodyDeclaration bd = bodyDeclarations.get(0);
if (!(bd instanceof ConstructorDeclaration)) {
throw new IllegalStateException("Illegal state: JavaParser did not return a method declaration correctly");
}
final ConstructorDeclaration cd = (ConstructorDeclaration) bd;
d.setBlock(cd.getBlock());
}
// already exists
for (final BodyDeclaration bd : members) {
if (bd instanceof ConstructorDeclaration) {
// Next constructor should appear after this current constructor
final ConstructorDeclaration cd = (ConstructorDeclaration) bd;
if (cd.getParameters().size() == d.getParameters().size()) {
// Possible match, we need to consider parameter types as
// well now
final ConstructorMetadata constructorMetadata = new JavaParserConstructorMetadataBuilder(constructor.getDeclaredByMetadataId(), cd, compilationUnitServices, typeParameters).build();
boolean matchesFully = true;
for (final AnnotatedJavaType existingParameter : constructorMetadata.getParameterTypes()) {
if (!existingParameter.getJavaType().equals(constructor.getParameterTypes().get(index))) {
matchesFully = false;
break;
}
}
if (matchesFully) {
throw new IllegalStateException("Constructor '" + constructor.getParameterNames() + "' already exists with identical parameters");
}
}
}
}
// ROO-3834: Append Javadoc
CommentStructure commentStructure = constructor.getCommentStructure();
if (constructor.getCommentStructure() != null) {
// annotation
if (annotations != null && annotations.size() > 0) {
AnnotationExpr firstAnnotation = annotations.get(0);
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(firstAnnotation, commentStructure);
// Otherwise, add comments to the field declaration line
} else {
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(d, commentStructure);
}
} else {
// ROO-3834: Append default Javadoc if not exists a comment structure,
// including constructor params
CommentStructure defaultCommentStructure = new CommentStructure();
List<String> parameterNames = new ArrayList<String>();
for (JavaSymbolName name : constructor.getParameterNames()) {
parameterNames.add(name.getSymbolName());
}
JavadocComment javadocComment = new JavadocComment("TODO Auto-generated constructor documentation", parameterNames, null, null);
defaultCommentStructure.addComment(javadocComment, CommentLocation.BEGINNING);
constructor.setCommentStructure(defaultCommentStructure);
// annotation
if (annotations != null && annotations.size() > 0) {
AnnotationExpr firstAnnotation = annotations.get(0);
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(firstAnnotation, defaultCommentStructure);
// Otherwise, add comments to the constructor declaration line
} else {
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(d, defaultCommentStructure);
}
}
// Add the constructor to the end of the compilation unit
members.add(d);
}
use of org.springframework.roo.classpath.details.comments.JavadocComment in project spring-roo by spring-projects.
the class JavaParserTypeParsingService method updateOutput.
/**
* Appends the presented class to the end of the presented body
* declarations. The body declarations appear within the presented
* compilation unit. This is used to progressively build inner types.
*
* @param compilationUnit the work-in-progress compilation unit (required)
* @param enclosingCompilationUnitServices
* @param cid the new class to add (required)
* @param parent the class body declarations a subclass should be added to
* (may be null, which denotes a top-level type within the
* compilation unit)
*/
private void updateOutput(final CompilationUnit compilationUnit, CompilationUnitServices enclosingCompilationUnitServices, final ClassOrInterfaceTypeDetails cid, final List<BodyDeclaration> parent) {
// Append the new imports this class declares
Validate.notNull(compilationUnit.getImports(), "Compilation unit imports should be non-null when producing type '%s'", cid.getName());
for (final ImportMetadata importType : cid.getRegisteredImports()) {
ImportDeclaration importDeclaration;
if (!importType.isAsterisk()) {
NameExpr typeToImportExpr;
if (importType.getImportType().getEnclosingType() == null) {
typeToImportExpr = new QualifiedNameExpr(new NameExpr(importType.getImportType().getPackage().getFullyQualifiedPackageName()), importType.getImportType().getSimpleTypeName());
} else {
typeToImportExpr = new QualifiedNameExpr(new NameExpr(importType.getImportType().getEnclosingType().getFullyQualifiedTypeName()), importType.getImportType().getSimpleTypeName());
}
importDeclaration = new ImportDeclaration(typeToImportExpr, importType.isStatic(), false);
} else {
importDeclaration = new ImportDeclaration(new NameExpr(importType.getImportPackage().getFullyQualifiedPackageName()), importType.isStatic(), importType.isAsterisk());
}
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(importDeclaration, importType.getCommentStructure());
compilationUnit.getImports().add(importDeclaration);
}
// Create a class or interface declaration to represent this actual type
final int javaParserModifier = JavaParserUtils.getJavaParserModifier(cid.getModifier());
TypeDeclaration typeDeclaration;
ClassOrInterfaceDeclaration classOrInterfaceDeclaration;
// Implements handling
final List<ClassOrInterfaceType> implementsList = new ArrayList<ClassOrInterfaceType>();
for (final JavaType current : cid.getImplementsTypes()) {
implementsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
}
if (cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE || cid.getPhysicalTypeCategory() == PhysicalTypeCategory.CLASS) {
final boolean isInterface = cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE;
if (parent == null) {
// Top level type
typeDeclaration = new ClassOrInterfaceDeclaration(javaParserModifier, isInterface, cid.getName().getNameIncludingTypeParameters().replace(cid.getName().getPackage().getFullyQualifiedPackageName() + ".", ""));
classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
} else {
// Inner type
typeDeclaration = new ClassOrInterfaceDeclaration(javaParserModifier, isInterface, cid.getName().getSimpleTypeName());
classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
if (cid.getName().getParameters().size() > 0) {
classOrInterfaceDeclaration.setTypeParameters(new ArrayList<TypeParameter>());
for (final JavaType param : cid.getName().getParameters()) {
NameExpr pNameExpr = JavaParserUtils.importTypeIfRequired(cid.getName(), compilationUnit.getImports(), param);
final String tempName = StringUtils.replace(pNameExpr.toString(), param.getArgName() + " extends ", "", 1);
pNameExpr = new NameExpr(tempName);
final ClassOrInterfaceType pResolvedName = JavaParserUtils.getClassOrInterfaceType(pNameExpr);
classOrInterfaceDeclaration.getTypeParameters().add(new TypeParameter(param.getArgName().getSymbolName(), Collections.singletonList(pResolvedName)));
}
}
}
// Superclass handling
final List<ClassOrInterfaceType> extendsList = new ArrayList<ClassOrInterfaceType>();
for (final JavaType current : cid.getExtendsTypes()) {
if (!OBJECT.equals(current)) {
extendsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
}
}
if (extendsList.size() > 0) {
classOrInterfaceDeclaration.setExtends(extendsList);
}
// Implements handling
if (implementsList.size() > 0) {
classOrInterfaceDeclaration.setImplements(implementsList);
}
} else {
typeDeclaration = new EnumDeclaration(javaParserModifier, cid.getName().getSimpleTypeName());
}
typeDeclaration.setMembers(new ArrayList<BodyDeclaration>());
Validate.notNull(typeDeclaration.getName(), "Missing type declaration name for '%s'", cid.getName());
// If adding a new top-level type, must add it to the compilation unit
// types
Validate.notNull(compilationUnit.getTypes(), "Compilation unit types must not be null when attempting to add '%s'", cid.getName());
if (parent == null) {
// Top-level class
compilationUnit.getTypes().add(typeDeclaration);
} else {
// Inner class
parent.add(typeDeclaration);
}
// CompilationUnitServices needs to be created
if (enclosingCompilationUnitServices == null) {
// Create a compilation unit so that we can use JavaType*Metadata
// static methods directly
enclosingCompilationUnitServices = new CompilationUnitServices() {
@Override
public JavaPackage getCompilationUnitPackage() {
return cid.getName().getPackage();
}
@Override
public JavaType getEnclosingTypeName() {
return cid.getName();
}
@Override
public List<ImportDeclaration> getImports() {
return compilationUnit.getImports();
}
@Override
public List<TypeDeclaration> getInnerTypes() {
return compilationUnit.getTypes();
}
@Override
public PhysicalTypeCategory getPhysicalTypeCategory() {
return cid.getPhysicalTypeCategory();
}
};
}
final CompilationUnitServices finalCompilationUnitServices = enclosingCompilationUnitServices;
// A hybrid CompilationUnitServices must be provided that references the
// enclosing types imports and package
final CompilationUnitServices compilationUnitServices = new CompilationUnitServices() {
@Override
public JavaPackage getCompilationUnitPackage() {
return finalCompilationUnitServices.getCompilationUnitPackage();
}
@Override
public JavaType getEnclosingTypeName() {
return cid.getName();
}
@Override
public List<ImportDeclaration> getImports() {
return finalCompilationUnitServices.getImports();
}
@Override
public List<TypeDeclaration> getInnerTypes() {
return compilationUnit.getTypes();
}
@Override
public PhysicalTypeCategory getPhysicalTypeCategory() {
return cid.getPhysicalTypeCategory();
}
};
// Add type annotations
final List<AnnotationExpr> annotations = new ArrayList<AnnotationExpr>();
typeDeclaration.setAnnotations(annotations);
for (final AnnotationMetadata candidate : cid.getAnnotations()) {
JavaParserAnnotationMetadataBuilder.addAnnotationToList(compilationUnitServices, annotations, candidate);
}
// ROO-3834: Generating default Javadoc inside class if class doesn't contains JavaDoc
List<Comment> classComments = compilationUnit.getComments();
if (classComments == null || classComments.isEmpty()) {
CommentStructure defaultCommentStructure = new CommentStructure();
String defaultComment = "= ".concat(cid.getType().getSimpleTypeName()).concat("\n \nTODO Auto-generated class documentation");
defaultCommentStructure.addComment(new JavadocComment(defaultComment), CommentLocation.BEGINNING);
if (annotations.isEmpty()) {
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(typeDeclaration, defaultCommentStructure);
} else {
// If exists some annotation, include comment before the existing annotations
AnnotationExpr firstAnnotation = annotations.get(0);
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(firstAnnotation, defaultCommentStructure);
}
}
// Add enum constants and interfaces
if (typeDeclaration instanceof EnumDeclaration && cid.getEnumConstants().size() > 0) {
final EnumDeclaration enumDeclaration = (EnumDeclaration) typeDeclaration;
final List<EnumConstantDeclaration> constants = new ArrayList<EnumConstantDeclaration>();
enumDeclaration.setEntries(constants);
for (final JavaSymbolName constant : cid.getEnumConstants()) {
addEnumConstant(constants, constant);
}
// Implements handling
if (implementsList.size() > 0) {
enumDeclaration.setImplements(implementsList);
}
}
// Add fields
for (final FieldMetadata candidate : cid.getDeclaredFields()) {
JavaParserFieldMetadataBuilder.addField(compilationUnitServices, typeDeclaration.getMembers(), candidate);
}
// Add constructors
for (final ConstructorMetadata candidate : cid.getDeclaredConstructors()) {
JavaParserConstructorMetadataBuilder.addConstructor(compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
}
// Add methods
for (final MethodMetadata candidate : cid.getDeclaredMethods()) {
JavaParserMethodMetadataBuilder.addMethod(compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
}
// Add inner types
for (final ClassOrInterfaceTypeDetails candidate : cid.getDeclaredInnerTypes()) {
updateOutput(compilationUnit, compilationUnitServices, candidate, typeDeclaration.getMembers());
}
final HashSet<String> imported = new HashSet<String>();
final ArrayList<ImportDeclaration> imports = new ArrayList<ImportDeclaration>();
for (final ImportDeclaration importDeclaration : compilationUnit.getImports()) {
JavaPackage importPackage = null;
JavaType importType = null;
if (importDeclaration.isAsterisk()) {
importPackage = new JavaPackage(importDeclaration.getName().toString());
} else {
importType = new JavaType(importDeclaration.getName().toString());
importPackage = importType.getPackage();
}
if (importPackage.equals(cid.getName().getPackage()) && importDeclaration.isAsterisk()) {
continue;
}
if (importPackage.equals(cid.getName().getPackage()) && importType != null && importType.getEnclosingType() == null) {
continue;
}
if (importType != null && importType.equals(cid.getName())) {
continue;
}
if (!imported.contains(importDeclaration.getName().toString())) {
imports.add(importDeclaration);
imported.add(importDeclaration.getName().toString());
}
}
Collections.sort(imports, new Comparator<ImportDeclaration>() {
@Override
public int compare(final ImportDeclaration importDeclaration, final ImportDeclaration importDeclaration1) {
return importDeclaration.getName().toString().compareTo(importDeclaration1.getName().toString());
}
});
compilationUnit.setImports(imports);
}
use of org.springframework.roo.classpath.details.comments.JavadocComment in project spring-roo by spring-projects.
the class ItdSourceFileComposer method appendConstructors.
private void appendConstructors() {
final List<? extends ConstructorMetadata> constructors = itdTypeDetails.getDeclaredConstructors();
if (constructors == null || constructors.isEmpty()) {
return;
}
content = true;
for (final ConstructorMetadata constructor : constructors) {
Validate.isTrue(constructor.getParameterTypes().size() == constructor.getParameterNames().size(), "Mismatched parameter names against parameter types");
// ROO-3447: Append comments if exists
CommentStructure commentStructure = constructor.getCommentStructure();
if (commentStructure != null && commentStructure.getBeginComments() != null) {
List<AbstractComment> constructorComments = commentStructure.getBeginComments();
String comment = "";
boolean missingComponentsAdded = false;
for (AbstractComment constructorComment : constructorComments) {
// Join all JavadocComment's
if (constructorComment instanceof JavadocComment) {
// Add JavaDoc missing components
if (!missingComponentsAdded) {
if (!constructor.getParameterNames().isEmpty() && ((JavadocComment) constructorComment).getParamsInfo() == null) {
List<String> paramsInfo = new ArrayList<String>();
for (JavaSymbolName name : constructor.getParameterNames()) {
paramsInfo.add(name.getSymbolName());
}
((JavadocComment) constructorComment).setParamsInfo(paramsInfo);
}
}
missingComponentsAdded = true;
comment = comment.concat(constructorComment.getComment()).concat(IOUtils.LINE_SEPARATOR);
} else {
// Not JavadocComment, write comment as it is, unchanged
appendFormalLine(constructorComment.getComment());
}
}
// Write JavadocComment's to ITD, in a single JavadocComment instance
String[] commentLines = comment.split(IOUtils.LINE_SEPARATOR);
for (String commentLine : commentLines) {
appendFormalLine(commentLine);
}
} else {
// ROO-3834: Append default Javadoc if not exists a comment structure,
// including constructor params
CommentStructure defaultCommentStructure = new CommentStructure();
List<String> parameterNames = new ArrayList<String>();
for (JavaSymbolName name : constructor.getParameterNames()) {
parameterNames.add(name.getSymbolName());
}
JavadocComment javadocComment = new JavadocComment("TODO Auto-generated constructor documentation", parameterNames, null, null);
defaultCommentStructure.addComment(javadocComment, CommentLocation.BEGINNING);
constructor.setCommentStructure(defaultCommentStructure);
// Now lines should be formatted, so write them
String[] comment = javadocComment.getComment().split(IOUtils.LINE_SEPARATOR);
for (String line : comment) {
appendFormalLine(line);
}
}
// Append annotations
for (final AnnotationMetadata annotation : constructor.getAnnotations()) {
appendIndent();
outputAnnotation(annotation);
this.newLine(false);
}
// Append "<modifier> <TargetOfIntroduction>.new" portion
appendIndent();
if (constructor.getModifier() != 0) {
append(Modifier.toString(constructor.getModifier()));
append(" ");
}
append(introductionTo.getSimpleTypeName());
append(".");
append("new");
// Append parameter types and names
append("(");
final List<AnnotatedJavaType> parameterTypes = constructor.getParameterTypes();
final List<JavaSymbolName> parameterNames = constructor.getParameterNames();
for (int i = 0; i < parameterTypes.size(); i++) {
final AnnotatedJavaType paramType = parameterTypes.get(i);
final JavaSymbolName paramName = parameterNames.get(i);
for (final AnnotationMetadata methodParameterAnnotation : paramType.getAnnotations()) {
append(AnnotationMetadataUtils.toSourceForm(methodParameterAnnotation, resolver));
append(" ");
}
append(paramType.getJavaType().getNameIncludingTypeParameters(false, resolver));
append(" ");
append(paramName.getSymbolName());
if (i < parameterTypes.size() - 1) {
append(", ");
}
}
append(") {");
this.newLine(false);
indent();
// Add body
append(constructor.getBody());
indentRemove();
appendFormalLine("}");
this.newLine(false);
}
}
use of org.springframework.roo.classpath.details.comments.JavadocComment in project spring-roo by spring-projects.
the class ItdSourceFileComposer method appendFields.
private void appendFields() {
final List<? extends FieldMetadata> fields = itdTypeDetails.getDeclaredFields();
if (fields == null || fields.isEmpty()) {
return;
}
content = true;
for (final FieldMetadata field : fields) {
// ROO-3447: Append comments if exists
CommentStructure commentStructure = field.getCommentStructure();
if (commentStructure != null && commentStructure.getBeginComments() != null) {
List<AbstractComment> comments = commentStructure.getBeginComments();
String commentString = "";
for (AbstractComment comment : comments) {
// Join all JavadocComment's
if (comment instanceof JavadocComment) {
commentString = commentString.concat(comment.getComment()).concat(IOUtils.LINE_SEPARATOR);
} else {
// Not JavadocComment, write comment as it is, unchanged
appendFormalLine(comment.getComment());
}
}
// Write JavadocComment's to ITD, in a single JavadocComment instance
String[] commentLines = commentString.split(IOUtils.LINE_SEPARATOR);
for (String commentLine : commentLines) {
appendFormalLine(commentLine);
}
} else {
// ROO-3834: Append default Javadoc if not exists a comment structure
JavadocComment javadocComment = new JavadocComment("TODO Auto-generated attribute documentation");
// Now lines should be formatted, so write them
String[] comment = javadocComment.getComment().split(IOUtils.LINE_SEPARATOR);
for (String line : comment) {
appendFormalLine(line);
}
}
// Append annotations
for (final AnnotationMetadata annotation : field.getAnnotations()) {
appendIndent();
outputAnnotation(annotation);
this.newLine(false);
}
// Append "<modifier> <fieldType> <fieldName>" portion
appendIndent();
if (field.getModifier() != 0) {
append(Modifier.toString(field.getModifier()));
append(" ");
}
append(field.getFieldType().getNameIncludingTypeParameters(false, resolver));
append(" ");
append(introductionTo.getSimpleTypeName());
append(".");
append(field.getFieldName().getSymbolName());
// Append initializer, if present
if (field.getFieldInitializer() != null) {
append(" = ");
append(field.getFieldInitializer());
}
// Complete the field declaration
append(";");
this.newLine(false);
this.newLine();
}
}
Aggregations