Examples of com.github.antlrjavaparser.api.expr.MemberValuePair

Package com.github.antlrjavaparser.api.expr

Examples of com.github.antlrjavaparser.api.expr.MemberValuePair

com.github.antlrjavaparser.api.expr.MemberValuePair

        }
        
        // 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

View Full Code Here

            final AnnotationAttributeValue<?> value = annotation
                    .getAttribute(attributeName);
            Validate.notNull(value,
                    "Unable to acquire value '%s' from annotation",
                    attributeName);
            final MemberValuePair memberValuePair = convert(value);
            // Validate.notNull(memberValuePair,
            // "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()) {
            // Have to check here for cases where we need to change an existing
            // MarkerAnnotationExpr to a NormalAnnotationExpr or
            // 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");

View Full Code Here

                        JavaParserUtils.getNameExpr(nestedAnnotation
                                .getAnnotationType()
                                .getFullyQualifiedTypeName()), memberValuePairs);
            }
            // 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.getNameExpr(castValue
                    .getFullyQualifiedTypeName());
            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);
                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()

View Full Code Here

        }
        else if (annotationExpr instanceof SingleMemberAnnotationExpr) {
            final SingleMemberAnnotationExpr a = (SingleMemberAnnotationExpr) annotationExpr;
            // Add the "value=" member-value pair.
            if (a.getMemberValue() != null) {
                annotationPairs.add(new MemberValuePair("value", a
                        .getMemberValue()));
            }
        }
        else if (annotationExpr instanceof NormalAnnotationExpr) {
            final NormalAnnotationExpr a = (NormalAnnotationExpr) annotationExpr;

View Full Code Here

TOP

Related Classes of com.github.antlrjavaparser.api.expr.MemberValuePair

org.springframework.roo.classpath.antlrjavaparser.details.JavaParserAnnotationMetadataBuilder

org.springframework.roo.classpath.antlrjavaparser.UpdateCompilationUnitUtils

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.