Examples of japa.parser.ast.expr.SingleMemberAnnotationExpr

japa.parser.ast.expr.SingleMemberAnnotationExpr
@author Julio Vilmar Gesser

                    "Unable to determine annotation name from '"
                            + annotationExpr + "'");
            return nameToFind;
        }
        else if (annotationExpr instanceof SingleMemberAnnotationExpr) {
            final SingleMemberAnnotationExpr a = (SingleMemberAnnotationExpr) annotationExpr;
            final NameExpr nameToFind = a.getName();
            Validate.notNull(nameToFind,
                    "Unable to determine annotation name from '"
                            + annotationExpr + "'");
            return nameToFind;
        }
        else if (annotationExpr instanceof NormalAnnotationExpr) {
            final NormalAnnotationExpr a = (NormalAnnotationExpr) annotationExpr;
            final NameExpr nameToFind = a.getName();
            Validate.notNull(nameToFind,
                    "Unable to determine annotation name from '"
                            + annotationExpr + "'");
            return nameToFind;
        }

View Full Code Here

            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
        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);
                    annotations.add(annotationExpression);
                }
                else {
                    // We have a number of pairs being presented
                    annotationExpression = new NormalAnnotationExpr(nameToUse,
                            new ArrayList<MemberValuePair>());
                    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(

View Full Code Here

                        JavaParserUtils.getNameExpr(nestedAnnotation
                                .getAnnotationType()
                                .getFullyQualifiedTypeName()));
            }
            else if (castValue.getValue().getAttributeNames().size() == 1) {
                annotationExpr = new SingleMemberAnnotationExpr(
                        JavaParserUtils.getNameExpr(nestedAnnotation
                                .getAnnotationType()
                                .getFullyQualifiedTypeName()), convert(
                                nestedAnnotation.getAttribute(nestedAnnotation
                                        .getAttributeNames().get(0)))

View Full Code Here

        List<MemberValuePair> annotationPairs = new ArrayList<MemberValuePair>();
        if (annotationExpr instanceof MarkerAnnotationExpr) {
            // A marker annotation has no values, so we can have no pairs to add
        }
        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;
            // Must iterate over the expressions
            if (a.getPairs() != null) {
                annotationPairs = a.getPairs();
            }
        }


        // Iterate over the annotation attributes, creating our parsed
        // attributes map

View Full Code Here


        return Boolean.TRUE;
    }


    public Boolean visit(SingleMemberAnnotationExpr n1, Node arg) {
        SingleMemberAnnotationExpr n2 = (SingleMemberAnnotationExpr) arg;


        if (!nodeEquals(n1.getName(), n2.getName())) {
            return Boolean.FALSE;
        }


        if (!nodeEquals(n1.getMemberValue(), n2.getMemberValue())) {
            return Boolean.FALSE;
        }


        return Boolean.TRUE;
    }

View Full Code Here

        jj_consume_token(LPAREN);
        memberVal = MemberValue();
        jj_consume_token(RPAREN);
        {
            if (true) {
                return new SingleMemberAnnotationExpr(line, column, token.endLine, token.endColumn, name, memberVal);
            }
        }
        throw new Error("Missing return statement in function");
    }

View Full Code Here

    helper.assertCompile();


    //
    JavaFile file = helper.assertJavaSource("metamodel.tag.package-info");
    PackageDeclaration a = file.assertPackage();
    SingleMemberAnnotationExpr applicationDecl = (SingleMemberAnnotationExpr)a.getAnnotations().get(0);
    NormalAnnotationExpr tagDecl = (NormalAnnotationExpr)applicationDecl.getMemberValue();
    boolean changed = false;
    for (MemberValuePair pair : tagDecl.getPairs()) {
      if (pair.getName().equals("path")) {
        pair.setValue(new StringLiteralExpr("bar.gtmpl"));
        changed = true;

View Full Code Here

  public Node visit(SingleMemberAnnotationExpr _n, Object _arg) {
    NameExpr name = cloneNodes(_n.getName(), _arg);
    Expression memberValue = cloneNodes(_n.getMemberValue(), _arg);
    Comment comment = cloneNodes(_n.getComment(), _arg);


    SingleMemberAnnotationExpr r = new SingleMemberAnnotationExpr(
        _n.getBeginLine(), _n.getBeginColumn(), _n.getEndLine(), _n.getEndColumn(),
        name, memberValue
    );
    r.setComment(comment);
    return r;
  }

View Full Code Here


    return Boolean.TRUE;
  }


  @Override public Boolean visit(final SingleMemberAnnotationExpr n1, final Node arg) {
    final SingleMemberAnnotationExpr n2 = (SingleMemberAnnotationExpr) arg;


    if (!nodeEquals(n1.getName(), n2.getName())) {
      return Boolean.FALSE;
    }


    if (!nodeEquals(n1.getMemberValue(), n2.getMemberValue())) {
      return Boolean.FALSE;
    }


    return Boolean.TRUE;
  }

View Full Code Here

TOP

Related Classes of japa.parser.ast.expr.SingleMemberAnnotationExpr

japa.parser.ast.visitor.CloneVisitor

japa.parser.ast.visitor.EqualsVisitor

japa.parser.ASTParser

juzu.impl.metamodel.TagMetaModelTestCase

org.springframework.roo.classpath.javaparser.details.JavaParserAnnotationMetadataBuilder

org.springframework.roo.classpath.javaparser.JavaParserUtils

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.