if (ModifierSet.isAbstract(modifiers)) { result |= Modifier.ABSTRACT; if (ModifierSet.isFinal(modifiers)) { result |= Modifier.FINAL; if (ModifierSet.isNative(modifiers)) { result |= Modifier.NATIVE; if (ModifierSet.isPrivate(modifiers)) { result |= Modifier.PRIVATE; if (ModifierSet.isProtected(modifiers)) { result |= Modifier.PROTECTED; if (ModifierSet.isPublic(modifiers)) { result |= Modifier.PUBLIC; if (ModifierSet.isStatic(modifiers)) { result |= Modifier.STATIC; if (ModifierSet.isStrictfp(modifiers)) { result |= Modifier.STRICT; if (ModifierSet.isSynchronized(modifiers)) { result |= Modifier.SYNCHRONIZED; if (ModifierSet.isTransient(modifiers)) { result |= Modifier.TRANSIENT;
/** * Compares Type, modifies and annotation of two {@link FieldDeclaration} * * @param fieldDeclaration * @param fieldDeclaration2 * @return */ public static boolean equalFieldTypeModifiersAnnotations(final FieldDeclaration fieldDeclaration, final FieldDeclaration fieldDeclaration2) { return fieldDeclaration.getModifiers() == fieldDeclaration2.getModifiers() && equals(fieldDeclaration.getType(), fieldDeclaration2.getType()) && equalsAnnotations(fieldDeclaration.getAnnotations(), fieldDeclaration2.getAnnotations()); }
/** * Compares two {@link MethodDeclaration} * * @param originalMethod * @param newMethod * @return */ private static boolean equals(final MethodDeclaration originalMethod, final MethodDeclaration newMethod) { return originalMethod.getModifiers() == newMethod.getModifiers() && originalMethod.getName().equals(newMethod.getName()) && equalsParameters(originalMethod.getParameters(), newMethod.getParameters()) && equals(originalMethod.getBody(), newMethod.getBody()); }
String fieldName; FieldDeclaration field; if (newType.getMembers() != null) { for (final BodyDeclaration element : newType.getMembers()) { if (element instanceof FieldDeclaration) { field = (FieldDeclaration) element; for (final VariableDeclarator variable : field.getVariables()) { fieldName = variable.getId().getName(); cidFields.put(fieldName, new FieldEntry(field, variable)); if (originalType.getMembers() != null) { for (final Iterator<BodyDeclaration> originalMemberstIter = originalType.getMembers().iterator(); originalMemberstIter.hasNext();) { final BodyDeclaration originalMember = originalMemberstIter.next(); if (!(originalMember instanceof FieldDeclaration)) { for (final Iterator<VariableDeclarator> variablesIter = field.getVariables().iterator(); variablesIter .hasNext();) { final VariableDeclarator originalVariable = variablesIter.next(); fieldName = originalVariable.getId().getName(); if (field.getVariables().size() == 1) { field.setModifiers(entry.fieldDeclaration.getModifiers()); field.setType(entry.fieldDeclaration.getType()); if (field.getAnnotations() == null && entry.fieldDeclaration.getAnnotations() != null) { field.setAnnotations(new ArrayList<AnnotationExpr>()); updateAnnotations(field.getAnnotations(), entry.fieldDeclaration.getAnnotations());
Validate.notNull(fieldDeclaration, "Field declaration is mandatory"); Validate.notNull(var, "Variable declarator required"); Validate.isTrue(fieldDeclaration.getVariables().contains(var), "Cannot request a variable not already in the field declaration"); Validate.notNull(compilationUnitServices, "Compilation unit services are required"); modifier = JavaParserUtils.getJdkModifier(fieldDeclaration.getModifiers()); final Type type = fieldDeclaration.getType(); fieldType = JavaParserUtils.getJavaType(compilationUnitServices, type, typeParameters); if (var.getId().getArrayCount() > 0) { fieldType = new JavaType(fieldType.getFullyQualifiedTypeName(), var.getId().getArrayCount() + fieldType.getArray(), fieldType.getDataType(), fieldType.getArgName(), fieldType.getParameters()); fieldName = new JavaSymbolName(var.getId().getName()); final Expression e = var.getInit(); if (e != null) { fieldInitializer = e.toString(); final List<AnnotationExpr> annotations = fieldDeclaration.getAnnotations(); if (annotations != null) { for (final AnnotationExpr annotation : annotations) {
modifier = JavaParserUtils.getJdkModifier(constructorDeclaration.getModifiers()); final List<TypeParameter> params = constructorDeclaration.getTypeParameters(); if (params != null) { for (final TypeParameter candidate : params) { body = constructorDeclaration.getBlock().toString(); body = StringUtils.replace(body, "{", "", 1); body = body.substring(0, body.lastIndexOf("}")); if (constructorDeclaration.getParameters() != null) { for (final Parameter p : constructorDeclaration.getParameters()) { final Type pt = p.getType(); final JavaType parameterType = JavaParserUtils.getJavaType(compilationUnitServices, pt, fullTypeParameters); final List<AnnotationExpr> annotationsList = p.getAnnotations(); final List<AnnotationMetadata> annotations = new ArrayList<AnnotationMetadata>(); if (annotationsList != null) { parameterNames.add(new JavaSymbolName(p.getId().getName())); if (constructorDeclaration.getAnnotations() != null) { for (final AnnotationExpr annotation : constructorDeclaration.getAnnotations()) { annotations.add(JavaParserAnnotationMetadataBuilder.getInstance(annotation, compilationUnitServices).build());
if (newType.getMembers() != null) { for (final BodyDeclaration element : newType.getMembers()) { if (element instanceof ConstructorDeclaration) { cidConstructor.add((ConstructorDeclaration) element); boolean notFound; if (originalType.getMembers() != null) { for (final Iterator<BodyDeclaration> originalMemberstIter = originalType.getMembers().iterator(); originalMemberstIter.hasNext();) { final BodyDeclaration originalMember = originalMemberstIter.next(); if (!(originalMember instanceof ConstructorDeclaration)) { if (originalConstructor.getModifiers() != newConstructor.getModifiers()) { originalConstructor.setModifiers(newConstructor.getModifiers()); if (!equalsAnnotations(originalConstructor.getAnnotations(), newConstructor.getAnnotations())) { originalConstructor.setAnnotations(newConstructor.getAnnotations()); if (!equals(originalConstructor.getBlock(), newConstructor.getBlock())) { originalConstructor.setBlock(newConstructor.getBlock()); if (originalType.getMembers() == null) { originalType.setMembers(new ArrayList<BodyDeclaration>()); originalType.getMembers().addAll(cidConstructor);
/** * Updates {@code originalType} enumeration from {@code newType} information * * @param originalType * @param newType */ private static void updateCompilationUnitEnumeration(final EnumDeclaration originalType, final EnumDeclaration newType) { if (originalType.getModifiers() != newType.getModifiers()) { originalType.setModifiers(newType.getModifiers()); } if (originalType.getAnnotations() == null && newType.getAnnotations() != null) { originalType.setAnnotations(new ArrayList<AnnotationExpr>()); } if (!equalsEnumConstants(originalType.getEntries(), newType.getEntries())) { originalType.setEntries(newType.getEntries()); } updateAnnotations(originalType.getAnnotations(), newType.getAnnotations()); updateFields(originalType, newType); updateConstructors(originalType, newType); updateMethods(originalType, newType); }
parameter = parameters.get(i); parameter2 = parameters2.get(i); if (!parameter.getId().getName().equals(parameter2.getId().getName())) { return false; if (!equals(parameter.getType(), parameter2.getType())) { return false; if (!equalsAnnotations(parameter.getAnnotations(), parameter2.getAnnotations())) { return false;
if (!constant.getName().equals(constant2.getName())) { return false; if (!equalsAnnotations(constant.getAnnotations(), constant2.getAnnotations())) { return false; if (ObjectUtils.equals(constant.getClassBody(), constant2.getClassBody())) { return true; if (constant.getClassBody() == null || constant2.getClassBody() == null) { return false; final List<BodyDeclaration> body = constant.getClassBody(); final List<BodyDeclaration> body2 = constant2.getClassBody(); if (body.size() != body2.size()) { return false; if (!item.toString().equals(item2.toString())) { return false;
public static void removeField(final CompilationUnitServices compilationUnitServices, final List<BodyDeclaration> members, final JavaSymbolName fieldName) { Validate.notNull(compilationUnitServices, "Flushable compilation unit services required"); Validate.notNull(members, "Members required"); Validate.notNull(fieldName, "Field name to remove is required"); // Locate the field int i = -1; int toDelete = -1; for (final BodyDeclaration bd : members) { i++; if (bd instanceof FieldDeclaration) { final FieldDeclaration fieldDeclaration = (FieldDeclaration) bd; for (final VariableDeclarator var : fieldDeclaration.getVariables()) { if (var.getId().getName().equals(fieldName.getSymbolName())) { toDelete = i; break; } } } } Validate.isTrue(toDelete > -1, "Could not locate field '%s' to delete", fieldName); // Do removal outside iteration of body declaration members, to avoid // concurrent modification exceptions members.remove(toDelete); }
/** * Update {@code originalType} annotation, fields, methods... from * {@code cidCompilationUnit} information * * @param originalType * @param newType */ public static void updateCompilationUnitType(final TypeDeclaration originalType, final TypeDeclaration newType) { if (originalType.getModifiers() != newType.getModifiers()) { originalType.setModifiers(newType.getModifiers()); } if (originalType.getAnnotations() == null && newType.getAnnotations() != null) { originalType.setAnnotations(new ArrayList<AnnotationExpr>()); } updateAnnotations(originalType.getAnnotations(), newType.getAnnotations()); updateFields(originalType, newType); updateConstructors(originalType, newType); updateMethods(originalType, newType); updateInnerTypes(originalType, newType); // Check if TypeDeclarations are instance of ClassOrInterfaceDeclaration // to be able to obtain extends and implements types if (originalType instanceof ClassOrInterfaceDeclaration && newType instanceof ClassOrInterfaceDeclaration) { updateExtends((ClassOrInterfaceDeclaration) originalType, (ClassOrInterfaceDeclaration) newType); updateImplements((ClassOrInterfaceDeclaration) originalType, (ClassOrInterfaceDeclaration) newType); } }
/** * Update {@code extends} with {@code } * * @param originalType * @param newType */ private static void updateExtends(final ClassOrInterfaceDeclaration originalType, final ClassOrInterfaceDeclaration newType) { // Getting original an new extends List<ClassOrInterfaceType> originalExtends = originalType.getExtends() == null ? new ArrayList<ClassOrInterfaceType>() : originalType .getExtends(); List<ClassOrInterfaceType> newExtends = newType.getExtends() == null ? new ArrayList<ClassOrInterfaceType>() : newType.getExtends(); // Check if has the same extends if (!originalExtends.equals(newExtends)) { // If not, merge extends and add it to original List<ClassOrInterfaceType> finalExtends = originalExtends; for (ClassOrInterfaceType x : newExtends) { if (!finalExtends.contains(x)) { finalExtends.add(x); } } originalType.setExtends(finalExtends); } }
originalType.getImplements() == null ? new ArrayList<ClassOrInterfaceType>() : originalType .getImplements(); List<ClassOrInterfaceType> newImplements = newType.getImplements() == null ? new ArrayList<ClassOrInterfaceType>() : newType .getImplements(); originalType.setImplements(finalImplements);
private void addEnumConstant(final List<EnumConstantDeclaration> constants, final JavaSymbolName name) { // Determine location to insert for (final EnumConstantDeclaration constant : constants) { if (constant.getName().equals(name.getSymbolName())) { throw new IllegalArgumentException("Enum constant '" + name.getSymbolName() + "' already exists"); } } final EnumConstantDeclaration newEntry = new EnumConstantDeclaration(name.getSymbolName()); constants.add(constants.size(), newEntry); }
final NameExpr nameExpr = getNameExpr(typeDeclaration.getName()); final JavaType effectiveType = getJavaType(compilationUnitServices, nameExpr, null); final ClassOrInterfaceDeclaration clazz = (ClassOrInterfaceDeclaration) typeDeclaration; final List<TypeParameter> typeParameters = clazz.getTypeParameters(); if (typeParameters != null) { final Set<JavaSymbolName> locatedTypeParameters = new HashSet<JavaSymbolName>();
/** * Compares {@code originalConstructor} declaration to * {@code newConstructor} <br> * This compares constructor parameters and its types * * @param originalConstructor * @param newConstructor * @return true if declaration are equals */ private static boolean equalsDeclaration(final ConstructorDeclaration originalConstructor, final ConstructorDeclaration newConstructor) { if (!equalsParameters(originalConstructor.getParameters(), newConstructor.getParameters())) { return false; } return true; }
/** * Searches a compilation unit and locates the declaration with the given * type's simple name. * * @param compilationUnit to scan (required) * @param javaType the target to locate (required) * @return the located type declaration or null if it could not be found */ public static TypeDeclaration locateTypeDeclaration(final CompilationUnit compilationUnit, final JavaType javaType) { Validate.notNull(compilationUnit, "Compilation unit required"); Validate.notNull(javaType, "Java type to search for required"); if (compilationUnit.getTypes() == null) { return null; } for (final TypeDeclaration candidate : compilationUnit.getTypes()) { if (javaType.getSimpleTypeName().equals(candidate.getName())) { // We have the required type declaration return candidate; } } return null; }
/** * Adapt the roo interface to the antlr-java-parser interface * * @param rooComment * @return */ private static Comment adaptComment( final org.springframework.roo.classpath.details.comments.AbstractComment rooComment) { Comment comment; if (rooComment instanceof org.springframework.roo.classpath.details.comments.LineComment) { comment = new LineComment(); } else if (rooComment instanceof org.springframework.roo.classpath.details.comments.JavadocComment) { comment = new JavadocComment(); } else { comment = new BlockComment(); } comment.setContent(rooComment.getComment()); return comment; } }
int result = 0; if (Modifier.isAbstract(modifiers)) { result = ModifierSet.addModifier(ModifierSet.ABSTRACT, result); result = ModifierSet.addModifier(ModifierSet.FINAL, result); result = ModifierSet.addModifier(ModifierSet.NATIVE, result); result = ModifierSet.addModifier(ModifierSet.PRIVATE, result); result = ModifierSet.addModifier(ModifierSet.PROTECTED, result); result = ModifierSet.addModifier(ModifierSet.PUBLIC, result); result = ModifierSet.addModifier(ModifierSet.STATIC, result); result = ModifierSet.addModifier(ModifierSet.STRICTFP, result); result = ModifierSet.addModifier(ModifierSet.SYNCHRONIZED, result); result = ModifierSet.addModifier(ModifierSet.TRANSIENT, result); result = ModifierSet.addModifier(ModifierSet.VOLATILE, result);