use of com.github.antlrjavaparser.api.expr.MemberValuePair in project spring-roo by spring-projects.
the class UpdateCompilationUnitUtils method equals.
/**
* Compares to {@link MemberValuePair} list
*
* @param pairs1
* @param pairs2
* @return
*/
private static boolean equals(List<MemberValuePair> pairs1, List<MemberValuePair> pairs2) {
if (ObjectUtils.equals(pairs1, pairs2)) {
return true;
}
if (pairs1 == null || pairs2 == null) {
return false;
}
if (pairs1.size() != pairs2.size()) {
return false;
}
// Clone pair2 to better performance
List<MemberValuePair> pairs2Cloned = new ArrayList<MemberValuePair>(pairs2);
MemberValuePair pair2;
Iterator<MemberValuePair> pairIterator;
boolean found;
// For every pair in 1
for (MemberValuePair pair1 : pairs1) {
found = false;
pairIterator = pairs2Cloned.iterator();
// Iterate over remaining pair2 elements
while (pairIterator.hasNext()) {
pair2 = pairIterator.next();
if (pair1.getName().equals(pair2.getName())) {
// Found name
found = true;
// Remove from remaining pair2 elements
pairIterator.remove();
// compare value
if (ObjectUtils.equals(pair1.getValue(), pair2.getValue())) {
// Equals: check for pair1 finished
break;
} else {
String value1 = ObjectUtils.defaultIfNull(pair1.getValue(), "").toString();
String value2 = ObjectUtils.defaultIfNull(pair2.getValue(), "").toString();
if (value1.equals(value2)) {
// Equals: check for pair1 finished
break;
} else {
// Not equals: return false
return false;
}
}
}
}
if (!found) {
// Pair1 not found: return false
return false;
}
}
return true;
}
use of com.github.antlrjavaparser.api.expr.MemberValuePair in project spring-roo by spring-projects.
the class JavaParserAnnotationMetadataBuilder method addAnnotationToList.
/**
* Facilitates the addition of the annotation to the presented type.
*
* @param compilationUnitServices to use (required)
* @param annotations to add to the end of (required)
* @param annotation to add (required)
*/
public static void addAnnotationToList(final CompilationUnitServices compilationUnitServices, final List<AnnotationExpr> annotations, final AnnotationMetadata annotation) {
Validate.notNull(compilationUnitServices, "Compilation unit services required");
Validate.notNull(annotations, "Annotations required");
Validate.notNull(annotation, "Annotation metadata required");
// ROO-3678: Add-on which include new annotation should be the responsible to check if annotation
// exists, not JavaParser.
/*// Create a holder for the annotation we're going to create
boolean foundExisting = false;
// Search for an existing annotation of this type
for (final AnnotationExpr candidate : annotations) {
NameExpr existingName = null;
if (candidate instanceof NormalAnnotationExpr) {
existingName = ((NormalAnnotationExpr) candidate).getName();
}
else if (candidate instanceof MarkerAnnotationExpr) {
existingName = ((MarkerAnnotationExpr) candidate).getName();
}
else if (candidate instanceof SingleMemberAnnotationExpr) {
existingName = ((SingleMemberAnnotationExpr) candidate)
.getName();
}
// Convert the candidate annotation type's into a JavaType
final JavaType javaType = JavaParserUtils.getJavaType(
compilationUnitServices, existingName, null);
if (annotation.getAnnotationType().equals(javaType)) {
foundExisting = true;
break;
}
}
Validate.isTrue(!foundExisting,
"Found an existing annotation for type '%s'",
annotation.getAnnotationType());*/
// Import the annotation type, if needed
final NameExpr nameToUse = JavaParserUtils.importTypeIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), annotation.getAnnotationType());
// Create member-value pairs in accordance with Java Parser requirements
final List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
for (final JavaSymbolName attributeName : annotation.getAttributeNames()) {
final AnnotationAttributeValue<?> value = annotation.getAttribute(attributeName);
Validate.notNull(value, "Unable to acquire value '%s' from annotation", attributeName);
final MemberValuePair memberValuePair = convert(value, compilationUnitServices);
// "Member value pair should have been set");
if (memberValuePair != null) {
memberValuePairs.add(memberValuePair);
}
}
// Create the AnnotationExpr; it varies depending on how many
// member-value pairs we need to present
AnnotationExpr annotationExpression = null;
if (memberValuePairs.isEmpty()) {
annotationExpression = new MarkerAnnotationExpr(nameToUse);
} else if (memberValuePairs.size() == 1 && (memberValuePairs.get(0).getName() == null || "value".equals(memberValuePairs.get(0).getName()))) {
final Expression toUse = JavaParserUtils.importExpressionIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), memberValuePairs.get(0).getValue());
annotationExpression = new SingleMemberAnnotationExpr(nameToUse, toUse);
} else {
// We have a number of pairs being presented
annotationExpression = new NormalAnnotationExpr(nameToUse, new ArrayList<MemberValuePair>());
}
// Add our AnnotationExpr to the actual annotations that will eventually
// be flushed through to the compilation unit
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(annotationExpression, annotation.getCommentStructure());
annotations.add(annotationExpression);
// Add member-value pairs to our AnnotationExpr
if (!memberValuePairs.isEmpty()) {
// SingleMemberAnnotationExpr
if (annotationExpression instanceof MarkerAnnotationExpr) {
final MarkerAnnotationExpr mae = (MarkerAnnotationExpr) annotationExpression;
annotations.remove(mae);
if (memberValuePairs.size() == 1 && (memberValuePairs.get(0).getName() == null || "value".equals(memberValuePairs.get(0).getName()))) {
final Expression toUse = JavaParserUtils.importExpressionIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), memberValuePairs.get(0).getValue());
annotationExpression = new SingleMemberAnnotationExpr(nameToUse, toUse);
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(annotationExpression, annotation.getCommentStructure());
annotations.add(annotationExpression);
} else {
// We have a number of pairs being presented
annotationExpression = new NormalAnnotationExpr(nameToUse, new ArrayList<MemberValuePair>());
JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(annotationExpression, annotation.getCommentStructure());
annotations.add(annotationExpression);
}
}
if (annotationExpression instanceof SingleMemberAnnotationExpr) {
// Potentially upgrade this expression to a NormalAnnotationExpr
final SingleMemberAnnotationExpr smae = (SingleMemberAnnotationExpr) annotationExpression;
if (memberValuePairs.size() == 1 && memberValuePairs.get(0).getName() == null || memberValuePairs.get(0).getName().equals("value") || memberValuePairs.get(0).getName().equals("")) {
// They specified only a single member-value pair, and it is
// the default anyway, so we need not do anything except
// update the value
final Expression toUse = JavaParserUtils.importExpressionIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), memberValuePairs.get(0).getValue());
smae.setMemberValue(toUse);
return;
}
// There is > 1 expression, or they have provided some sort of
// non-default value, so it's time to upgrade the expression
// (whilst retaining any potentially existing expression values)
final Expression existingValue = smae.getMemberValue();
annotationExpression = new NormalAnnotationExpr(smae.getName(), new ArrayList<MemberValuePair>());
((NormalAnnotationExpr) annotationExpression).getPairs().add(new MemberValuePair("value", existingValue));
}
Validate.isInstanceOf(NormalAnnotationExpr.class, annotationExpression, "Attempting to add >1 annotation member-value pair requires an existing normal annotation expression");
final List<MemberValuePair> annotationPairs = ((NormalAnnotationExpr) annotationExpression).getPairs();
annotationPairs.clear();
for (final MemberValuePair pair : memberValuePairs) {
final Expression toUse = JavaParserUtils.importExpressionIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), pair.getValue());
pair.setValue(toUse);
annotationPairs.add(pair);
}
}
}
use of com.github.antlrjavaparser.api.expr.MemberValuePair in project spring-roo by spring-projects.
the class JavaParserAnnotationMetadataBuilder method convert.
@SuppressWarnings("unchecked")
private static MemberValuePair convert(final AnnotationAttributeValue<?> value, CompilationUnitServices compilationUnitServices) {
if (value instanceof NestedAnnotationAttributeValue) {
final NestedAnnotationAttributeValue castValue = (NestedAnnotationAttributeValue) value;
AnnotationExpr annotationExpr;
final AnnotationMetadata nestedAnnotation = castValue.getValue();
if (castValue.getValue().getAttributeNames().size() == 0) {
annotationExpr = new MarkerAnnotationExpr(JavaParserUtils.getNameExpr(nestedAnnotation.getAnnotationType().getSimpleTypeName()));
} else if (castValue.getValue().getAttributeNames().size() == 1 && (castValue.getValue().getAttributeNames().get(0) == null || "value".equals(castValue.getValue().getAttributeNames().get(0).getSymbolName()))) {
annotationExpr = new SingleMemberAnnotationExpr(JavaParserUtils.getNameExpr(nestedAnnotation.getAnnotationType().getSimpleTypeName()), convert(nestedAnnotation.getAttribute(nestedAnnotation.getAttributeNames().get(0)), compilationUnitServices).getValue());
} else {
final List<MemberValuePair> memberValuePairs = new ArrayList<MemberValuePair>();
for (final JavaSymbolName attributeName : nestedAnnotation.getAttributeNames()) {
memberValuePairs.add(convert(nestedAnnotation.getAttribute(attributeName), compilationUnitServices));
}
annotationExpr = new NormalAnnotationExpr(JavaParserUtils.getNameExpr(nestedAnnotation.getAnnotationType().getSimpleTypeName()), memberValuePairs);
}
// Add imports for nested annotation types
JavaParserUtils.importTypeIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), nestedAnnotation.getAnnotationType());
// Rely on the nested instance to know its member value pairs
return new MemberValuePair(value.getName().getSymbolName(), annotationExpr);
}
if (value instanceof BooleanAttributeValue) {
final boolean castValue = ((BooleanAttributeValue) value).getValue();
final BooleanLiteralExpr convertedValue = new BooleanLiteralExpr(castValue);
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof CharAttributeValue) {
final char castValue = ((CharAttributeValue) value).getValue();
final CharLiteralExpr convertedValue = new CharLiteralExpr(new String(new char[] { castValue }));
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof LongAttributeValue) {
final Long castValue = ((LongAttributeValue) value).getValue();
final LongLiteralExpr convertedValue = new LongLiteralExpr(castValue.toString() + "L");
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof IntegerAttributeValue) {
final Integer castValue = ((IntegerAttributeValue) value).getValue();
final IntegerLiteralExpr convertedValue = new IntegerLiteralExpr(castValue.toString());
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof DoubleAttributeValue) {
final DoubleAttributeValue doubleAttributeValue = (DoubleAttributeValue) value;
final Double castValue = doubleAttributeValue.getValue();
DoubleLiteralExpr convertedValue;
if (doubleAttributeValue.isFloatingPrecisionOnly()) {
convertedValue = new DoubleLiteralExpr(castValue.toString() + "F");
} else {
convertedValue = new DoubleLiteralExpr(castValue.toString() + "D");
}
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof StringAttributeValue) {
final String castValue = ((StringAttributeValue) value).getValue();
final StringLiteralExpr convertedValue = new StringLiteralExpr(castValue.toString());
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof EnumAttributeValue) {
final EnumDetails castValue = ((EnumAttributeValue) value).getValue();
// This isn't as elegant as it could be (ie loss of type
// parameters), but it will do for now
final FieldAccessExpr convertedValue = new FieldAccessExpr(JavaParserUtils.getNameExpr(castValue.getType().getFullyQualifiedTypeName()), castValue.getField().getSymbolName());
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof ClassAttributeValue) {
final JavaType castValue = ((ClassAttributeValue) value).getValue();
// This doesn't preserve type parameters
final NameExpr nameExpr = JavaParserUtils.importTypeIfRequired(compilationUnitServices.getEnclosingTypeName(), compilationUnitServices.getImports(), castValue);
final ClassExpr convertedValue = new ClassExpr(JavaParserUtils.getReferenceType(nameExpr));
return new MemberValuePair(value.getName().getSymbolName(), convertedValue);
}
if (value instanceof ArrayAttributeValue) {
final ArrayAttributeValue<AnnotationAttributeValue<?>> castValue = (ArrayAttributeValue<AnnotationAttributeValue<?>>) value;
final List<Expression> arrayElements = new ArrayList<Expression>();
for (final AnnotationAttributeValue<?> v : castValue.getValue()) {
final MemberValuePair converted = convert(v, compilationUnitServices);
if (converted != null) {
arrayElements.add(converted.getValue());
}
}
return new MemberValuePair(value.getName().getSymbolName(), new ArrayInitializerExpr(arrayElements));
}
throw new UnsupportedOperationException("Unsupported attribute value '" + value.getName() + "' of type '" + value.getClass().getName() + "'");
}
use of com.github.antlrjavaparser.api.expr.MemberValuePair in project spring-roo by spring-projects.
the class JavaParserUtils method importExpressionIfRequired.
/**
* Recognises {@link Expression}s of type {@link FieldAccessExpr} and
* {@link ClassExpr} and automatically imports them if required, returning
* the correct {@link Expression} that should subsequently be used.
* <p>
* Even if an {@link Expression} is not resolved by this method into a type
* and/or imported, the method guarantees to always return an
* {@link Expression} that the caller can subsequently use in place of the
* passed {@link Expression}. In practical terms, the {@link Expression}
* passed to this method will be returned unless the type was already
* imported, just imported, or represented a java.lang type.
*
* @param targetType the compilation unit target type (required)
* @param imports the existing imports (required)
* @param value that expression, which need not necessarily be resolvable to
* a type (required)
* @return the expression to now use, as appropriately resolved (never
* returns null)
*/
public static Expression importExpressionIfRequired(final JavaType targetType, final List<ImportDeclaration> imports, final Expression value) {
Validate.notNull(targetType, "Target type required");
Validate.notNull(imports, "Imports required");
Validate.notNull(value, "Expression value required");
if (value instanceof FieldAccessExpr) {
final Expression scope = ((FieldAccessExpr) value).getScope();
final String field = ((FieldAccessExpr) value).getField();
if (scope instanceof QualifiedNameExpr) {
final String packageName = ((QualifiedNameExpr) scope).getQualifier().getName();
final String simpleName = ((QualifiedNameExpr) scope).getName();
final String fullyQualifiedName = packageName + "." + simpleName;
final JavaType javaType = new JavaType(fullyQualifiedName);
final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType);
if (!(nameToUse instanceof QualifiedNameExpr)) {
return new FieldAccessExpr(nameToUse, field);
}
}
} else if (value instanceof ClassExpr) {
final Type type = ((ClassExpr) value).getType();
if (type instanceof ClassOrInterfaceType) {
final JavaType javaType = new JavaType(((ClassOrInterfaceType) type).getName());
final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType);
if (!(nameToUse instanceof QualifiedNameExpr)) {
return new ClassExpr(new ClassOrInterfaceType(javaType.getSimpleTypeName()));
}
} else if (type instanceof ReferenceType && ((ReferenceType) type).getType() instanceof ClassOrInterfaceType) {
final ClassOrInterfaceType cit = (ClassOrInterfaceType) ((ReferenceType) type).getType();
final JavaType javaType = new JavaType(cit.getName());
final NameExpr nameToUse = importTypeIfRequired(targetType, imports, javaType);
if (!(nameToUse instanceof QualifiedNameExpr)) {
return new ClassExpr(new ClassOrInterfaceType(javaType.getSimpleTypeName()));
}
}
} else if (value instanceof ArrayInitializerExpr) {
List<Expression> values = ((ArrayInitializerExpr) value).getValues();
for (Expression expressionValue : values) {
// Check annotation expression
if (expressionValue instanceof NormalAnnotationExpr) {
Validate.isInstanceOf(NormalAnnotationExpr.class, expressionValue, "Attempting to add >1 annotation member-value pair requires an existing normal annotation expression");
final List<MemberValuePair> annotationPairs = ((NormalAnnotationExpr) expressionValue).getPairs();
for (final MemberValuePair pair : annotationPairs) {
final Expression toUse = JavaParserUtils.importExpressionIfRequired(targetType, imports, pair.getValue());
pair.setValue(toUse);
}
}
}
}
// Make no changes
return value;
}
Aggregations