Example usage for org.eclipse.jdt.core.dom MethodDeclaration MODIFIERS2_PROPERTY

List of usage examples for org.eclipse.jdt.core.dom MethodDeclaration MODIFIERS2_PROPERTY

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. MethodDeclaration
  6. MODIFIERS2_PROPERTY

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom MethodDeclaration MODIFIERS2_PROPERTY.

Prototype

ChildListPropertyDescriptor MODIFIERS2_PROPERTY

To view the source code for org.eclipse.jdt.core.dom MethodDeclaration MODIFIERS2_PROPERTY.

Click Source Link

Document

The "modifiers" structural property of this node type (element type: IExtendedModifier ) (added in JLS3 API).

Usage

From source file:com.gowan.plugin.handlers.JUnit3Handler.java

License:Open Source License

private void transformMethod(AST ast, ASTRewrite rewrite, MethodDeclaration original, String annotationName) {
    ListRewrite setupRw = rewrite.getListRewrite(original, MethodDeclaration.MODIFIERS2_PROPERTY);
    MarkerAnnotation annotation = ast.newMarkerAnnotation();
    annotation.setTypeName(ast.newSimpleName(annotationName));
    setupRw.insertFirst(annotation, null);

    List<IExtendedModifier> modifiers = original.modifiers();
    Annotation override = null;/*  w w  w.j  av a  2 s.c om*/
    for (IExtendedModifier iExtendedModifier : modifiers) {
        if (iExtendedModifier.isAnnotation()) {
            Annotation localAnnotation = (Annotation) iExtendedModifier;
            String fullName = localAnnotation.getTypeName().getFullyQualifiedName();
            if ("java.lang.Override".equals(fullName) || "Override".equals(fullName)) {
                override = localAnnotation;
                break;
            }
        }
    }
    try {
        setupRw.remove(override, null);
    } catch (IllegalArgumentException e) {
    }
}

From source file:edu.umd.cs.findbugs.plugin.eclipse.quickfix.ChangePublicToProtectedResolution.java

License:Open Source License

@Override
protected void repairBug(ASTRewrite rewrite, CompilationUnit workingUnit, BugInstance bug)
        throws BugResolutionException {
    Assert.isNotNull(rewrite);//from ww w  .  j av  a2 s  . c om
    Assert.isNotNull(workingUnit);
    Assert.isNotNull(bug);

    TypeDeclaration type = getTypeDeclaration(workingUnit, bug.getPrimaryClass());
    MethodDeclaration method = getMethodDeclaration(type, bug.getPrimaryMethod());
    Modifier originalModifier = getPublicModifier(method);

    ListRewrite listRewrite = rewrite.getListRewrite(method, MethodDeclaration.MODIFIERS2_PROPERTY);
    Modifier protectedModifier = workingUnit.getAST().newModifier(PROTECTED_KEYWORD);
    listRewrite.replace(originalModifier, protectedModifier, null);
}

From source file:edu.umd.cs.findbugs.quickfix.resolution.ChangePublicToProtectedResolution.java

License:Open Source License

@Override
protected void repairBug(ASTRewrite rewrite, CompilationUnit workingUnit, BugInstance bug)
        throws BugResolutionException {
    assert rewrite != null;
    assert workingUnit != null;
    assert bug != null;

    TypeDeclaration type = getTypeDeclaration(workingUnit, bug.getPrimaryClass());
    MethodDeclaration method = getMethodDeclaration(type, bug.getPrimaryMethod());
    Modifier originalModifier = getPublicModifier(method);

    ListRewrite listRewrite = rewrite.getListRewrite(method, MethodDeclaration.MODIFIERS2_PROPERTY);
    Modifier protectedModifier = workingUnit.getAST().newModifier(PROTECTED_KEYWORD);
    listRewrite.replace(originalModifier, protectedModifier, null);
}

From source file:jmockit.assist.ASTUtil.java

License:Open Source License

public static void addAnnotation(final String annotation, final IJavaProject project, final ASTRewrite rewrite,
        final MethodDeclaration decl, final IMethodBinding binding) {
    String version = project.getOption(JavaCore.COMPILER_COMPLIANCE, true);

    if (!binding.getDeclaringClass().isInterface()
            || !JavaModelUtil.isVersionLessThan(version, JavaCore.VERSION_1_6)) {
        final Annotation marker = rewrite.getAST().newMarkerAnnotation();
        marker.setTypeName(rewrite.getAST().newSimpleName(annotation)); //$NON-NLS-1$
        rewrite.getListRewrite(decl, MethodDeclaration.MODIFIERS2_PROPERTY).insertFirst(marker, null);
    }//  w ww .  j a  va  2 s . c o  m
}

From source file:org.gw4e.eclipse.facade.JDTManager.java

License:Open Source License

/**
 * @param project// w  w  w  .  j a  va2 s  . co m
 * @param itype
 * @return
 * @throws JavaModelException
 */
public static Map<String, List<String>> findSetPathGeneratorInvocation(IProject project, IType itype)
        throws JavaModelException {
    Map<String, List<String>> ret = new HashMap<String, List<String>>();
    ICompilationUnit cu = itype.getCompilationUnit();
    CompilationUnit ast = parse(cu);

    ast.accept(new ASTVisitor() {
        public boolean visit(MethodDeclaration node) {
            List<?> modifiers = (List<?>) node.getStructuralProperty(MethodDeclaration.MODIFIERS2_PROPERTY);
            for (Object modifier : modifiers) {
                if (modifier instanceof org.eclipse.jdt.core.dom.Annotation) {
                    IAnnotationBinding annotationBinding = ((org.eclipse.jdt.core.dom.Annotation) modifier)
                            .resolveAnnotationBinding();
                    if (annotationBinding != null) {

                        final String qualifiedName = annotationBinding.getAnnotationType().getQualifiedName();

                        if ("org.junit.Test".equalsIgnoreCase(qualifiedName)) {
                            Map<String, String> variables = new HashMap<String, String>();
                            node.accept(new ASTVisitor() {
                                public boolean visit(VariableDeclarationStatement node) {
                                    for (int i = 0; i < node.fragments().size(); ++i) {
                                        VariableDeclarationFragment frag = (VariableDeclarationFragment) node
                                                .fragments().get(i);
                                        if (isContext(node.getType().resolveBinding())) {
                                            Expression initializer = frag.getInitializer();
                                            JDTManager.ExpressionVisitor ev = new ExpressionVisitor(variables);
                                            initializer.accept(ev);
                                            if (ev.getValue() != null) {
                                                variables.put(frag.getName().getFullyQualifiedName(),
                                                        ev.getValue());
                                            }
                                        }
                                    }
                                    return true;
                                }

                                public boolean visit(MethodInvocation node) {
                                    SimpleName simpleName = node.getName();

                                    IBinding bding = simpleName.resolveBinding();

                                    if (bding instanceof IMethodBinding) {
                                        IMethodBinding imb = (IMethodBinding) bding;
                                        if ("setPathGenerator".equalsIgnoreCase(imb.getName())) {
                                            ITypeBinding[] arguments = imb.getParameterTypes();
                                            if (arguments.length == 1) {
                                                if (isContext(imb.getDeclaringClass())
                                                        && PathGenerator.class.getName()
                                                                .equals(arguments[0].getQualifiedName())
                                                        && isContext(imb.getReturnType())) {
                                                    int start = node.getStartPosition();
                                                    int end = node.getLength();
                                                    try {
                                                        String code = cu.getSource().substring(start,
                                                                start + end);
                                                        // System.out.println(code);
                                                    } catch (JavaModelException e) {
                                                        ResourceManager.logException(e);
                                                    }
                                                    List args = node.arguments();
                                                    Expression argumentExpression = (Expression) args.get(0);
                                                    ITypeBinding typeBinding = argumentExpression
                                                            .resolveTypeBinding();
                                                    String parameterName = "";
                                                    if (typeBinding != null) {
                                                        parameterName = argumentExpression.toString();
                                                        JDTManager.ExpressionVisitor ev = new ExpressionVisitor(
                                                                variables);
                                                        Expression expression = node.getExpression();
                                                        expression.accept(ev);
                                                        if (ev.getValue() != null) {
                                                            String contextClass = ev.getValue();
                                                            List<String> generators = ret.get(contextClass);
                                                            if (generators == null) {
                                                                generators = new ArrayList<String>();
                                                                ret.put(contextClass, generators);
                                                            }

                                                            if (!"null".equals(parameterName)
                                                                    && !generators.contains(parameterName)) {
                                                                generators.add(parameterName);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    return true;
                                }
                            });
                        }
                    }
                }
            }
            return true;
        }
    });
    return ret;
}

From source file:org.hibernate.eclipse.jdt.ui.internal.jpa.process.ProcessEntityInfo.java

License:Open Source License

@SuppressWarnings("unchecked")
public boolean visit(TypeDeclaration node) {
    ITypeBinding typeBinding = node.resolveBinding();
    String nodeName = typeBinding == null ? null : typeBinding.getBinaryName();
    if (nodeName == null) {
        return false;
    }// ww  w .  jav a  2 s  . c  om
    entityInfo = entityInfos.getEntityInfo(nodeName);
    if (entityInfo == null) {
        return false;
    }
    if (entityInfo.isAddMappedSuperclassFlag()) {
        MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
        matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_MAPPEDSUPERCLASS));
        ListRewrite lrw = rewriter.getListRewrite(node, TypeDeclaration.MODIFIERS2_PROPERTY);
        lrw.insertFirst(matd, null);
    }
    if (entityInfo.isAddEntityFlag()) {
        MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
        matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_ENTITY));
        ListRewrite lrw = rewriter.getListRewrite(node, TypeDeclaration.MODIFIERS2_PROPERTY);
        lrw.insertFirst(matd, null);
    }
    /** /
    if (!entityInfo.isImplicitConstructorFlag() && !entityInfo.isDefaultConstructorFlag() &&
    entityInfo.isAddSerializableInterfaceFlag()) {
       // add serializable interface
       SimpleName sn = null;
       //if (!entityInfo.isAddSerializableInterfaceImportFlag()) {
    sn = rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_SERIALIZABLE);
       //}
       //else {
       //   sn = rewriter.getAST().newSimpleName(JPAConst.IMPORT_SERIALIZABLE);
       //}
       SimpleType st = rewriter.getAST().newSimpleType(sn);
       ListRewrite lrw = rewriter.getListRewrite(node, TypeDeclaration.SUPER_INTERFACE_TYPES_PROPERTY);
       lrw.insertFirst(st, null);
       // add "private static final long serialVersionUID = 1L;"
       // ...
    }
    /**/
    if (!entityInfo.isImplicitConstructorFlag() && !entityInfo.isDefaultConstructorFlag()
            && entityInfo.isAddSerializableInterfaceFlag()) {

        MethodDeclaration md = rewriter.getAST().newMethodDeclaration();
        md.setConstructor(true);
        Modifier modifier = rewriter.getAST().newModifier(Modifier.ModifierKeyword.PROTECTED_KEYWORD);
        md.modifiers().add(modifier);
        Block body = rewriter.getAST().newBlock();
        md.setBody(body);
        SimpleName sn = rewriter.getAST().newSimpleName(entityInfo.getName());
        md.setName(sn);
        ListRewrite lrw = rewriter.getListRewrite(node, TypeDeclaration.BODY_DECLARATIONS_PROPERTY);
        List<?> list = lrw.getOriginalList();
        MethodDeclaration insertBeforeNode = null;
        Iterator<?> it = list.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            if (obj instanceof MethodDeclaration) {
                insertBeforeNode = (MethodDeclaration) obj;
                break;
            }
        }
        if (insertBeforeNode == null) {
            lrw.insertLast(md, null);
        } else {
            lrw.insertBefore(md, insertBeforeNode, null);
        }
    }
    if (enableOptLock && entityInfo.isAddVersionFlag() && !entityInfo.hasVersionAnnotation()) {
        // add property "version", add getter/setter getVersion/setVersion,
        // add annotation for the property or for the getter
        //
        final String version = "version"; //$NON-NLS-1$
        final String versionType = "Integer"; //$NON-NLS-1$
        //
        VariableDeclarationFragment vdFragment = rewriter.getAST().newVariableDeclarationFragment();
        SimpleName variableName = rewriter.getAST().newSimpleName(version);
        vdFragment.setName(variableName);
        FieldDeclaration fieldVersion = rewriter.getAST().newFieldDeclaration(vdFragment);
        Modifier modifier = rewriter.getAST().newModifier(Modifier.ModifierKeyword.PROTECTED_KEYWORD);
        fieldVersion.modifiers().add(modifier);
        Name typeName = rewriter.getAST().newName(versionType);
        SimpleType type = rewriter.getAST().newSimpleType(typeName);
        fieldVersion.setType(type);
        //
        MethodDeclaration mdGetter = rewriter.getAST().newMethodDeclaration();
        modifier = rewriter.getAST().newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD);
        mdGetter.modifiers().add(modifier);
        Block body = rewriter.getAST().newBlock();
        ReturnStatement returnVersion = rewriter.getAST().newReturnStatement();
        variableName = rewriter.getAST().newSimpleName(version);
        returnVersion.setExpression(variableName);
        body.statements().add(returnVersion);
        mdGetter.setBody(body);
        SimpleName sn = rewriter.getAST().newSimpleName("getVersion"); //$NON-NLS-1$
        mdGetter.setName(sn);
        typeName = rewriter.getAST().newName(versionType);
        type = rewriter.getAST().newSimpleType(typeName);
        mdGetter.setReturnType2(type);
        //
        MethodDeclaration mdSetter = rewriter.getAST().newMethodDeclaration();
        modifier = rewriter.getAST().newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD);
        mdSetter.modifiers().add(modifier);
        body = rewriter.getAST().newBlock();
        Assignment assignment = rewriter.getAST().newAssignment();
        FieldAccess fieldAccess = rewriter.getAST().newFieldAccess();
        ThisExpression thisExpression = rewriter.getAST().newThisExpression();
        fieldAccess.setExpression(thisExpression);
        variableName = rewriter.getAST().newSimpleName(version);
        fieldAccess.setName(variableName);
        assignment.setLeftHandSide(fieldAccess);
        variableName = rewriter.getAST().newSimpleName(version);
        assignment.setRightHandSide(variableName);
        ExpressionStatement expressionStatement = rewriter.getAST().newExpressionStatement(assignment);
        body.statements().add(expressionStatement);
        mdSetter.setBody(body);
        sn = rewriter.getAST().newSimpleName("setVersion"); //$NON-NLS-1$
        mdSetter.setName(sn);
        SingleVariableDeclaration svd = rewriter.getAST().newSingleVariableDeclaration();
        variableName = rewriter.getAST().newSimpleName(version);
        svd.setName(variableName);
        typeName = rewriter.getAST().newName(versionType);
        type = rewriter.getAST().newSimpleType(typeName);
        svd.setType(type);
        mdSetter.parameters().add(svd);
        //
        ListRewrite lrw = rewriter.getListRewrite(node, TypeDeclaration.BODY_DECLARATIONS_PROPERTY);
        if (entityInfo.getVersionFieldGetter() != FieldGetterType.FIELD
                && entityInfo.getVersionFieldGetter() != FieldGetterType.FIELD_GETTER) {
            lrw.insertLast(fieldVersion, null);
        }
        if (entityInfo.getVersionFieldGetter() != FieldGetterType.GETTER
                && entityInfo.getVersionFieldGetter() != FieldGetterType.FIELD_GETTER) {
            lrw.insertLast(mdGetter, null);
            lrw.insertLast(mdSetter, null);
        }
        if (annotationStyle == AnnotStyle.FIELDS) {
            MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
            matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_VERSION));
            lrw = rewriter.getListRewrite(fieldVersion, FieldDeclaration.MODIFIERS2_PROPERTY);
            lrw.insertFirst(matd, null);
        } else if (annotationStyle == AnnotStyle.GETTERS) {
            MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
            matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_VERSION));
            lrw = rewriter.getListRewrite(mdGetter, MethodDeclaration.MODIFIERS2_PROPERTY);
            lrw.insertFirst(matd, null);
        }
    }
    return true;
}

From source file:org.hibernate.eclipse.jdt.ui.internal.jpa.process.ProcessEntityInfo.java

License:Open Source License

@SuppressWarnings("unchecked")
public boolean visit(MethodDeclaration node) {
    if (entityInfo == null) {
        return false;
    }/*from   ww  w  . j  a  v a 2s. c  o  m*/
    if (annotationStyle != AnnotStyle.GETTERS) {
        return true;
    }
    if (node.getName().getFullyQualifiedName().compareTo(entityInfo.getName()) == 0 || node.isConstructor()) {
        // this is constructor declaration
        return true;
    }
    // -) is it setter?
    if (node.getName().getIdentifier().startsWith("set") //$NON-NLS-1$
            && node.parameters().size() == 1) {
        // setter - do not process it
        return true;
    }
    // +) is it getter?
    if (!(node.getName().getIdentifier().startsWith("get") //$NON-NLS-1$
            || node.getName().getIdentifier().startsWith("is")) //$NON-NLS-1$
            || node.parameters().size() > 0) {
        // not the getter - do not process it
        return true;
    }
    Type type = node.getReturnType2();
    if (type == null) {
        return true;
    }
    String returnIdentifier = CollectEntityInfo.getReturnIdentifier(node);
    if (type.isSimpleType() || type.isPrimitiveType()) {
        if (entityInfo.isAddGeneratedValueFlag()) {
            String primaryIdName = entityInfo.getPrimaryIdName();
            boolean addGeneratedValueMarker = false;
            if (primaryIdName.equals(returnIdentifier)) {
                addGeneratedValueMarker = true;
            }
            if (addGeneratedValueMarker) {
                MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
                matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_GENERATED_VALUE));
                ListRewrite lrw = rewriter.getListRewrite(node, MethodDeclaration.MODIFIERS2_PROPERTY);
                lrw.insertFirst(matd, null);
            }
        }
        if (entityInfo.isAddPrimaryIdFlag()) {
            String primaryIdName = entityInfo.getPrimaryIdName();
            boolean addIdMarker = false;
            if (primaryIdName.equals(returnIdentifier)) {
                addIdMarker = true;
            }
            if (addIdMarker) {
                MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
                matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_ID));
                ListRewrite lrw = rewriter.getListRewrite(node, MethodDeclaration.MODIFIERS2_PROPERTY);
                lrw.insertFirst(matd, null);
            }
        }
        if (enableOptLock && entityInfo.isAddVersionFlag() && !entityInfo.hasVersionAnnotation()) {
            boolean addVersionMarker = false;
            if ("version".equals(returnIdentifier)) { //$NON-NLS-1$
                addVersionMarker = true;
            }
            if (addVersionMarker) {
                MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
                matd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_VERSION));
                ListRewrite lrw = rewriter.getListRewrite(node, MethodDeclaration.MODIFIERS2_PROPERTY);
                lrw.insertFirst(matd, null);
            }
        }
    }
    if (type.isSimpleType() && (AllEntitiesProcessor.columnLength != defaultStrLength)) {
        SimpleType simpleType = (SimpleType) type;
        String typeName = simpleType.getName().getFullyQualifiedName();
        if ("java.lang.String".equals(typeName) || "String".equals(typeName)) { //$NON-NLS-1$ //$NON-NLS-2$
            String fieldId = returnIdentifier;
            RefColumnInfo rci = entityInfo.getRefColumnInfo(fieldId);
            if (rci == null || !rci.isExist()) {
                // if there is no @Column annotation - create new @Column annotation
                // with user defined default value length 
                NormalAnnotation natd = rewriter.getAST().newNormalAnnotation();
                natd.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_COLUMN));
                ListRewrite lrw = rewriter.getListRewrite(node, MethodDeclaration.MODIFIERS2_PROPERTY);
                lrw.insertFirst(natd, null);
                MemberValuePair mvp = rewriter.getAST().newMemberValuePair();
                mvp.setName(rewriter.getAST().newSimpleName("length")); //$NON-NLS-1$
                NumberLiteral nl = rewriter.getAST().newNumberLiteral(String.valueOf(defaultStrLength));
                mvp.setValue(nl);
                natd.values().add(mvp);
            }
        }
    }
    if (type.isSimpleType() || type.isParameterizedType() || type.isArrayType()) {
        String fieldId = ""; //$NON-NLS-1$
        RefType refType = RefType.UNDEF;
        boolean annotated = false;
        String fullyQualifiedName2 = ""; //$NON-NLS-1$
        fieldId = returnIdentifier;
        refType = entityInfo.getFieldIdRelValue(fieldId);
        annotated = entityInfo.getFieldIdAnnotatedValue(fieldId);
        fullyQualifiedName2 = entityInfo.getFieldIdFQNameValue(fieldId);
        Set<RefFieldInfo> setRFI = entityInfo.getRefFieldInfoSet(fullyQualifiedName2);
        if (!annotated && setRFI != null && isSimilarType(type, fullyQualifiedName2)) {
            RefEntityInfo rei = entityInfo.getFieldIdRefEntityInfo(fieldId);
            // try to process bidirectional relationships:
            // nRefType == JPAConst.ONE2ONE - OneToOne - the owning side corresponds
            //              to the side that contains the corresponding foreign key
            // nRefType == JPAConst.MANY2ONE - ManyToOne - owning side is always the "many" side
            // nRefType == JPAConst.MANY2MANY - ManyToMany bidirectional relationships 
            //              either side may be the owning side
            if (setRFI.size() > 1 && refType != RefType.MANY2ONE) {
                if (rei.mappedBy == null || rei.mappedBy == "") { //$NON-NLS-1$
                    addSimpleMarkerAnnotation(node, JPAConst.getRefType(refType));
                } else {
                    // give to the user information about selected mapping
                    addComplexNormalAnnotation(node, JPAConst.getRefType(refType), rei);
                }
            } else if (refType == RefType.MANY2ONE || refType == RefType.ENUMERATED || rei.mappedBy == null
                    || rei.mappedBy == "") { //$NON-NLS-1$
                addSimpleMarkerAnnotation(node, JPAConst.getRefType(refType));
            } else {
                // in case of bidirectional OneToOne - mark both sides with mappedBy - 
                // user should select the right decision 
                addComplexNormalAnnotation(node, JPAConst.getRefType(refType), rei);
            }
        }
    }
    return true;
}

From source file:org.hibernate.eclipse.jdt.ui.internal.jpa.process.ProcessEntityInfo.java

License:Open Source License

public boolean addSimpleMarkerAnnotation(BodyDeclaration node, String name) {
    if (name == null || name.length() == 0) {
        return false;
    }// w w  w.ja v a  2s. co m
    MarkerAnnotation matd = rewriter.getAST().newMarkerAnnotation();
    matd.setTypeName(rewriter.getAST().newSimpleName(name));
    ListRewrite lrw = null;
    if (node instanceof FieldDeclaration) {
        lrw = rewriter.getListRewrite(node, FieldDeclaration.MODIFIERS2_PROPERTY);
    } else if (node instanceof MethodDeclaration) {
        lrw = rewriter.getListRewrite(node, MethodDeclaration.MODIFIERS2_PROPERTY);
    }
    if (lrw != null) {
        lrw.insertFirst(matd, null);
    }
    return true;
}

From source file:org.hibernate.eclipse.jdt.ui.internal.jpa.process.ProcessEntityInfo.java

License:Open Source License

@SuppressWarnings("unchecked")
public boolean addComplexNormalAnnotation(BodyDeclaration node, String name, RefEntityInfo rei) {
    if (name == null || name.length() == 0) {
        return false;
    }/*from   ww w . j  a v  a  2 s . c  o m*/
    NormalAnnotation natd = rewriter.getAST().newNormalAnnotation();
    MemberValuePair mvp = null;
    if (rei.mappedBy != null && (rei.owner == OwnerType.YES || rei.owner == OwnerType.UNDEF)) {
        mvp = rewriter.getAST().newMemberValuePair();
        mvp.setName(rewriter.getAST().newSimpleName("mappedBy")); //$NON-NLS-1$
        StringLiteral sl = rewriter.getAST().newStringLiteral();
        sl.setLiteralValue(rei.mappedBy);
        mvp.setValue(sl);
    }
    natd.setTypeName(rewriter.getAST().newSimpleName(name));
    if (mvp != null) {
        natd.values().add(mvp);
    }
    NormalAnnotation natd2 = null;
    /** /
    if (rei.owner == OwnerType.NO) {
       natd2 = rewriter.getAST().newNormalAnnotation();
       natd2.setTypeName(rewriter.getAST().newSimpleName(JPAConst.ANNOTATION_JOINCOLUMN));
       mvp = null;
       String fullyQualifiedName2 = rei.fullyQualifiedName;
       EntityInfo entryInfo2 = entities.get(fullyQualifiedName2);
       if (entryInfo2 != null) {
    mvp = rewriter.getAST().newMemberValuePair();
    mvp.setName(rewriter.getAST().newSimpleName("name")); //$NON-NLS-1$
    StringLiteral sl = rewriter.getAST().newStringLiteral();
    sl.setLiteralValue(entryInfo2.getPrimaryIdName());
    mvp.setValue(sl);
       }
       if (mvp != null) {
    natd2.values().add(mvp);
       }
    }
    /**/
    ListRewrite lrw = null;
    if (node instanceof FieldDeclaration) {
        lrw = rewriter.getListRewrite(node, FieldDeclaration.MODIFIERS2_PROPERTY);
    } else if (node instanceof MethodDeclaration) {
        lrw = rewriter.getListRewrite(node, MethodDeclaration.MODIFIERS2_PROPERTY);
    }
    if (lrw != null) {
        if (natd2 != null) {
            lrw.insertFirst(natd2, null);
        }
        lrw.insertFirst(natd, null);
    }
    return true;
}

From source file:org.jboss.tools.arquillian.ui.internal.refactoring.AddMissingTypeRefactoring.java

License:Open Source License

@Override
public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException {
    message = null;/*from  ww  w.java2 s.  co  m*/
    if (astRoot == null || (abstractMethodBindings == null && deploymentMethodName == null)) {
        message = CANNOT_FIND_A_DEPLOYMENT_METHOD;
        return null;
    }
    MethodDeclaration deploymentMethod = null;
    TextFileChange result = new TextFileChange(file.getName(), file);
    MultiTextEdit rootEdit = new MultiTextEdit();
    importRewrite = CodeStyleConfiguration.createImportRewrite(astRoot, true);
    if (astRoot.getAST().hasResolvedBindings()) {
        importRewrite.setUseContextToFilterImplicitImports(true);
    }
    rewrite = ASTRewrite.create(astRoot.getAST());
    IType fType = cUnit.findPrimaryType();
    if (fType.isAnonymous()) {
        final ClassInstanceCreation creation = (ClassInstanceCreation) ASTNodes
                .getParent(NodeFinder.perform(astRoot, fType.getNameRange()), ClassInstanceCreation.class);
        if (creation != null) {
            final AnonymousClassDeclaration declaration = creation.getAnonymousClassDeclaration();
            if (declaration != null)
                listRewriter = rewrite.getListRewrite(declaration,
                        AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY);
        }
    } else {
        final AbstractTypeDeclaration declaration = (AbstractTypeDeclaration) ASTNodes
                .getParent(NodeFinder.perform(astRoot, fType.getNameRange()), AbstractTypeDeclaration.class);
        if (declaration != null)
            listRewriter = rewrite.getListRewrite(declaration, declaration.getBodyDeclarationsProperty());
    }
    if (listRewriter == null) {
        throw new CoreException(new Status(IStatus.ERROR, ArquillianUIActivator.PLUGIN_ID, IStatus.ERROR,
                "Could not find the type element", null));
    }
    ast = astRoot.getAST();
    ReturnStatement returnStatement;
    if (abstractMethodBindings != null) {
        IMethodBinding abstractMethodBinding = null;
        for (IMethodBinding binding : abstractMethodBindings) {
            if (binding.getName().equals(deploymentMethodName)) {
                abstractMethodBinding = binding;
                break;
            }
        }
        if (abstractMethodBinding == null) {
            message = CANNOT_FIND_A_DEPLOYMENT_METHOD;
            return null;
        }
        deploymentMethod = ast.newMethodDeclaration();
        deploymentMethod.setName(ast.newSimpleName(deploymentMethodName));

        IJavaProject javaProject = abstractMethodBinding.getJavaElement().getJavaProject();
        String archiveTypeName = ArquillianUtility.ORG_JBOSS_SHRINKWRAP_API_SPEC_JAVA_ARCHIVE;
        if (javaProject != null && javaProject.isOpen()) {
            IProject project = javaProject.getProject();
            IFile pomFile = project.getFile(IMavenConstants.POM_FILE_NAME);
            if (pomFile != null && pomFile.exists()) {
                try {
                    IMavenProjectFacade facade = MavenPlugin.getMavenProjectRegistry().create(project,
                            new NullProgressMonitor());
                    MavenProject mavenProject = facade.getMavenProject(new NullProgressMonitor());
                    Model model = mavenProject.getModel();
                    String packaging = model.getPackaging();
                    if (ArquillianConstants.WAR.equals(packaging)) {
                        archiveTypeName = ArquillianUtility.ORG_JBOSS_SHRINKWRAP_API_SPEC_WEB_ARCHIVE;
                    }
                    if (ArquillianConstants.EAR.equals(packaging)) {
                        archiveTypeName = ArquillianUtility.ORG_JBOSS_SHRINKWRAP_API_SPEC_ENTERPRISE_ARCHIVE;
                    }
                    if (ArquillianConstants.RAR.equals(packaging)) {
                        archiveTypeName = ArquillianUtility.ORG_JBOSS_SHRINKWRAP_API_SPEC_RESOURCEADAPTER_ARCHIVE;
                    }
                } catch (CoreException e) {
                    ArquillianUIActivator.log(e);
                }
            }
        }
        int index = archiveTypeName.lastIndexOf("."); //$NON-NLS-1$
        String simpleArchiveName;
        if (index >= 0) {
            simpleArchiveName = archiveTypeName.substring(index + 1);
        } else {
            simpleArchiveName = archiveTypeName;
        }
        SimpleName type2 = ast.newSimpleName(simpleArchiveName);
        importRewrite.addImport(archiveTypeName);
        deploymentMethod.setReturnType2(ast.newSimpleType(type2));
        deploymentMethod.setConstructor(false);
        deploymentMethod.modifiers()
                .addAll(ASTNodeFactory.newModifiers(ast, Modifier.PUBLIC | Modifier.STATIC));

        Annotation marker = rewrite.getAST().newMarkerAnnotation();
        importRewrite.addImport(ArquillianUtility.ORG_JBOSS_ARQUILLIAN_CONTAINER_TEST_API_DEPLOYMENT);
        marker.setTypeName(rewrite.getAST().newSimpleName("Deployment")); //$NON-NLS-1$
        rewrite.getListRewrite(deploymentMethod, MethodDeclaration.MODIFIERS2_PROPERTY).insertFirst(marker,
                null);

        Block body = ast.newBlock();
        deploymentMethod.setBody(body);

        // XXXArchive archive = (XXXArchive) AbstractTest.createDeployment();
        String declaringClassQualifiedName = abstractMethodBinding.getDeclaringClass().getQualifiedName();
        importRewrite.addImport(declaringClassQualifiedName);
        String declaringClassName = abstractMethodBinding.getDeclaringClass().getName();
        MethodInvocation deploymentInvocation = ast.newMethodInvocation();
        deploymentInvocation.setExpression(ast.newName(declaringClassName));
        deploymentInvocation.setName(ast.newSimpleName(deploymentMethodName));
        VariableDeclarationFragment archiveDeclFragment = ast.newVariableDeclarationFragment();
        archiveDeclFragment.setName(ast.newSimpleName(ARCHIVE_VARIABLE));
        ITypeBinding returnType = abstractMethodBinding.getReturnType();
        if (!archiveTypeName.equals(returnType.getQualifiedName())) {
            CastExpression cast = ast.newCastExpression();
            cast.setType(ast.newSimpleType(ast.newName(simpleArchiveName)));
            cast.setExpression(deploymentInvocation);
            archiveDeclFragment.setInitializer(cast);
        } else {
            archiveDeclFragment.setInitializer(deploymentInvocation);
        }
        VariableDeclarationStatement vStatement = ast.newVariableDeclarationStatement(archiveDeclFragment);
        vStatement.setType(ast.newSimpleType(ast.newName(simpleArchiveName)));
        body.statements().add(vStatement);

        //return archive;
        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(ast.newSimpleName(ARCHIVE_VARIABLE));
        //body.statements().add(returnStatement);
    } else {
        for (MethodDeclaration md : deploymentMethodDeclarations) {
            if (deploymentMethodName.equals(md.getName().getIdentifier())) {
                deploymentMethod = md;
                break;
            }
        }
        if (deploymentMethod == null) {
            message = CANNOT_FIND_A_DEPLOYMENT_METHOD;
            return null;
        }
        returnStatement = getReturnStatement(deploymentMethod);
        ast = deploymentMethod.getAST();
        rewrite = ASTRewrite.create(ast);
    }

    if (returnStatement == null) {
        message = "Cannot find a return statement";
        return null;
    }

    Expression expression = returnStatement.getExpression();

    if (expression instanceof MethodInvocation) {
        int start = expression.getStartPosition();
        int length = expression.getLength();
        selectedExpression = getSelectedExpression(new SourceRange(start, length));
        tempName = ARCHIVE_VARIABLE;
        int i = 0;
        while (!checkTempName(tempName).isOK()) {
            tempName = tempName + i++;
        }
        createAndInsertTempDeclaration(start, length);
        addReplaceExpressionWithTemp();
        createStatements(tempName, className, deploymentMethod, returnStatement, rootEdit, pm);
    }
    if (expression instanceof SimpleName) {
        String name = ((SimpleName) expression).getIdentifier();
        createStatements(name, className, deploymentMethod, returnStatement, rootEdit, pm);
    }

    result.setEdit(rootEdit);
    return result;
}