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

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

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

Introduction

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

Prototype

public void setJavadoc(Javadoc docComment)

Source Link

Document

Sets or clears the doc comment node.

Usage

From source file:ac.at.tuwien.dsg.uml.statemachine.export.transformation.engines.AbstractStateMachineTestStrategy.java

License:Open Source License

/**
 * Creates abstract methods which return true   
 * @param javadoc//from   ww w  . j  a va2s.  c o  m
 * @param methodName
 * @param ast
 * @return an AST method declaration
 */
protected MethodDeclaration createAbstractAssertMethod(Javadoc javadoc, String methodName, AST ast) {

    MethodDeclaration method = ast.newMethodDeclaration();

    method.setJavadoc(javadoc);

    method.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
    method.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.ABSTRACT_KEYWORD));
    method.setName(ast.newSimpleName(methodName)); //escape all spaces in state name

    /**
     * add to method generic arguments  Object... arguments
     */
    SingleVariableDeclaration param = ast.newSingleVariableDeclaration();
    param.setName(ast.newSimpleName("arguments"));
    param.setType(ast.newSimpleType(ast.newName("Object")));
    param.setStructuralProperty(SingleVariableDeclaration.VARARGS_PROPERTY, true);

    method.setReturnType2(ast.newPrimitiveType(PrimitiveType.BOOLEAN));

    return method;
}

From source file:com.google.gdt.eclipse.designer.builders.GwtBuilder.java

License:Open Source License

/**
 * Generates Async type for given <code>RemoteService</code>.
 *///from   w ww  . j a  v a2  s  . c o  m
private void generateAsync(IPackageFragment servicePackage, ICompilationUnit serviceUnit) throws Exception {
    IJavaProject javaProject = serviceUnit.getJavaProject();
    // parse service unit
    CompilationUnit serviceRoot = Utils.parseUnit(serviceUnit);
    // prepare AST and start modifications recording
    AST ast = serviceRoot.getAST();
    serviceRoot.recordModifications();
    // modify imports (-com.google.gwt.*, -*Exception, +AsyncCallback) 
    {
        List<ImportDeclaration> imports = DomGenerics.imports(serviceRoot);
        // remove useless imports
        for (Iterator<ImportDeclaration> I = imports.iterator(); I.hasNext();) {
            ImportDeclaration importDeclaration = I.next();
            String importName = importDeclaration.getName().getFullyQualifiedName();
            if (importName.startsWith("com.google.gwt.user.client.rpc.")
                    || importName.equals("com.google.gwt.core.client.GWT")
                    || importName.endsWith("Exception")) {
                I.remove();
            }
        }
    }
    // add Async to the name
    TypeDeclaration serviceType = (TypeDeclaration) serviceRoot.types().get(0);
    String remoteServiceAsyncName = serviceType.getName().getIdentifier() + "Async";
    serviceType.setName(serviceRoot.getAST().newSimpleName(remoteServiceAsyncName));
    // update interfaces
    updateInterfacesOfAsync(javaProject, serviceRoot, serviceType);
    // change methods, fields and inner classes
    {
        List<BodyDeclaration> bodyDeclarations = DomGenerics.bodyDeclarations(serviceType);
        for (Iterator<BodyDeclaration> I = bodyDeclarations.iterator(); I.hasNext();) {
            BodyDeclaration bodyDeclaration = I.next();
            if (bodyDeclaration instanceof MethodDeclaration) {
                MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
                // make return type void
                Type returnType;
                {
                    returnType = methodDeclaration.getReturnType2();
                    methodDeclaration.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
                }
                // process JavaDoc
                {
                    Javadoc javadoc = methodDeclaration.getJavadoc();
                    if (javadoc != null) {
                        List<TagElement> tags = DomGenerics.tags(javadoc);
                        for (Iterator<TagElement> tagIter = tags.iterator(); tagIter.hasNext();) {
                            TagElement tag = tagIter.next();
                            if ("@gwt.typeArgs".equals(tag.getTagName())) {
                                tagIter.remove();
                            } else if ("@return".equals(tag.getTagName())) {
                                if (!tag.fragments().isEmpty()) {
                                    tag.setTagName("@param callback the callback to return");
                                } else {
                                    tagIter.remove();
                                }
                            } else if ("@wbp.gwt.Request".equals(tag.getTagName())) {
                                tagIter.remove();
                                addImport(serviceRoot, "com.google.gwt.http.client.Request");
                                methodDeclaration.setReturnType2(ast.newSimpleType(ast.newName("Request")));
                            }
                        }
                        // remove empty JavaDoc
                        if (tags.isEmpty()) {
                            methodDeclaration.setJavadoc(null);
                        }
                    }
                }
                // add AsyncCallback parameter
                {
                    addImport(serviceRoot, "com.google.gwt.user.client.rpc.AsyncCallback");
                    // prepare "callback" type
                    Type callbackType;
                    {
                        callbackType = ast.newSimpleType(ast.newName("AsyncCallback"));
                        Type objectReturnType = getObjectType(returnType);
                        ParameterizedType parameterizedType = ast.newParameterizedType(callbackType);
                        DomGenerics.typeArguments(parameterizedType).add(objectReturnType);
                        callbackType = parameterizedType;
                    }
                    // prepare "callback" parameter
                    SingleVariableDeclaration asyncCallback = ast.newSingleVariableDeclaration();
                    asyncCallback.setType(callbackType);
                    asyncCallback.setName(ast.newSimpleName("callback"));
                    // add "callback" parameter
                    DomGenerics.parameters(methodDeclaration).add(asyncCallback);
                }
                // remove throws
                methodDeclaration.thrownExceptions().clear();
            } else if (bodyDeclaration instanceof FieldDeclaration
                    || bodyDeclaration instanceof TypeDeclaration) {
                // remove the fields and inner classes
                I.remove();
            }
        }
    }
    // apply modifications to prepare new source code
    String newSource;
    {
        String source = serviceUnit.getBuffer().getContents();
        Document document = new Document(source);
        // prepare text edits
        MultiTextEdit edits = (MultiTextEdit) serviceRoot.rewrite(document, javaProject.getOptions(true));
        removeAnnotations(serviceType, source, edits);
        // prepare new source code
        edits.apply(document);
        newSource = document.get();
    }
    // update compilation unit
    {
        ICompilationUnit unit = servicePackage.createCompilationUnit(remoteServiceAsyncName + ".java",
                newSource, true, null);
        unit.getBuffer().save(null, true);
    }
}

From source file:com.idega.eclipse.ejbwizards.BeanCreator.java

License:Open Source License

protected MethodDeclaration getMethodDeclaration(AST ast, IMethod method, String methodName, String returnType,
        Set imports, boolean addJavadoc) throws JavaModelException {
    String[] exceptions = method.getExceptionTypes();
    String[] parameterTypes = method.getParameterTypes();
    String[] parameterNames = method.getParameterNames();

    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(getType(ast, returnType));
    methodConstructor.setName(ast.newSimpleName(methodName));
    if (returnType != null) {
        imports.add(getImportSignature(returnType));
    }/*w  w  w .  j ava  2  s.com*/

    for (int i = 0; i < exceptions.length; i++) {
        methodConstructor.thrownExceptions()
                .add(ast.newSimpleName(Signature.getSignatureSimpleName(exceptions[i])));
        imports.add(getImportSignature(Signature.toString(exceptions[i])));
    }

    for (int i = 0; i < parameterTypes.length; i++) {
        String parameterType = getReturnType(parameterTypes[i]);

        SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(getType(ast, parameterType));
        variableDeclaration.setName(ast.newSimpleName(parameterNames[i]));
        methodConstructor.parameters().add(variableDeclaration);

        imports.add(getImportSignature(Signature.toString(parameterTypes[i])));
    }

    if (addJavadoc) {
        methodConstructor.setJavadoc(getJavadoc(ast, method));
    }

    return methodConstructor;
}

From source file:com.motorola.studio.android.model.java.JavaClass.java

License:Apache License

/**
 * Adds documentation reference to a method (the see tag to the javadoc)
 * //from  w ww.ja  va2s. c o m
 * @param element The method declaration object
 * @param qualifiedClassName The full qualified class name to refer
 * @param methodName The method to refer
 * @param parameters The method parameters
 */
@SuppressWarnings("unchecked")
protected void addMethodReference(MethodDeclaration element, String qualifiedClassName, String methodName,
        Type[] parameters) {
    String[] fqnArray = getFQNAsArray(qualifiedClassName);

    MethodRef methodRef = ast.newMethodRef();
    methodRef.setQualifier(
            ast.newQualifiedName(ast.newName(getQualifier(fqnArray)), ast.newSimpleName(getName(fqnArray))));

    methodRef.setName(ast.newSimpleName(methodName));

    if ((parameters != null) && (parameters.length > 0)) {
        for (Type param : parameters) {
            MethodRefParameter methodParam = ast.newMethodRefParameter();
            methodParam.setType(param);
            methodRef.parameters().add(methodParam);
        }
    }

    Javadoc javadoc = element.getJavadoc();
    TagElement tagElement = ast.newTagElement();
    tagElement.setTagName(TagElement.TAG_SEE);

    if (javadoc == null) {
        javadoc = ast.newJavadoc();
        element.setJavadoc(javadoc);
    }

    tagElement.fragments().add(methodRef);
    javadoc.tags().add(tagElement);
}

From source file:de.akra.idocit.java.services.JavaInterfaceGenerator.java

License:Apache License

/**
 * Apply the changes to the methods with the documentations for the parameters.
 * /* ww w  .j a  v a2 s . co  m*/
 * @param methods
 *            The {@link JavaMethod} that should be processed.
 */
private static void updateMethods(List<JavaMethod> methods, IJavadocGenerator javadocGenerator)
        throws ParsingException {
    for (JavaMethod method : methods) {
        if (SignatureElementUtils.isOperationsDocChanged(method)) {
            List<JavadocTagElement> jDocTags = createMethodJavadocTagElements(method);

            MethodDeclaration methodDeclaration = method.getRefToASTNode();
            Javadoc javadoc = createOrUpdateJavadoc(jDocTags, method.getAdditionalTags(),
                    methodDeclaration.getJavadoc(), methodDeclaration.getAST(), method.getThematicGridName(),
                    javadocGenerator, method);

            // if an existing Javadoc was updated it must not be set again!
            if ((methodDeclaration.getJavadoc() == null && javadoc != null)
                    || (methodDeclaration.getJavadoc() != null && javadoc == null)) {
                methodDeclaration.setJavadoc(javadoc);
            }
        }
    }
}

From source file:de.crowdcode.kissmda.cartridges.simplejava.InterfaceGenerator.java

License:Apache License

/**
 * Generate Javadoc for Getter and Setter method.
 * //from www. j a va 2  s . c o  m
 * @param ast
 *            JDT AST tree
 * @param property
 *            UML Property
 * @param methodDeclaration
 *            MethodDeclaration for Getter and Setter
 */
public void generateGetterSetterJavadoc(AST ast, Property property, MethodDeclaration methodDeclaration) {
    EList<Comment> comments = property.getOwnedComments();
    for (Comment comment : comments) {
        Javadoc javadoc = ast.newJavadoc();
        generateJavadoc(ast, comment, javadoc);
        methodDeclaration.setJavadoc(javadoc);
    }
}

From source file:de.crowdcode.kissmda.cartridges.simplejava.InterfaceGenerator.java

License:Apache License

/**
 * Generate Javadoc for UML Operation.//from   w  ww.  j  a v  a  2  s.co m
 * 
 * @param ast
 *            AST tree JDT
 * @param operation
 *            UML Operation - Method
 * @param md
 *            MethodDeclaration
 */
public void generateMethodJavadoc(AST ast, Operation operation, MethodDeclaration md) {
    EList<Comment> comments = operation.getOwnedComments();
    for (Comment comment : comments) {
        Javadoc javadoc = ast.newJavadoc();
        generateJavadoc(ast, comment, javadoc);
        md.setJavadoc(javadoc);
    }
}

From source file:edu.illinois.compositerefactorings.refactorings.NewClassCreator.java

License:Open Source License

private MethodDeclaration createConstructor(String declaringTypeName, CompilationUnitRewrite cuRewrite)
        throws CoreException {
    AST ast = cuRewrite.getAST();//from ww  w  .  java 2 s . c  om
    ICompilationUnit unit = cuRewrite.getCu();
    IJavaProject project = unit.getJavaProject();

    MethodDeclaration methodDeclaration = ast.newMethodDeclaration();
    methodDeclaration.setName(ast.newSimpleName(fClassName));
    methodDeclaration.setConstructor(true);
    methodDeclaration.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    String lineDelimiter = StubUtility.getLineDelimiterUsed(unit);
    if (createComments(project)) {
        String comment = CodeGeneration.getMethodComment(unit, declaringTypeName, methodDeclaration, null,
                lineDelimiter);
        if (comment != null) {
            Javadoc doc = (Javadoc) cuRewrite.getASTRewrite().createStringPlaceholder(comment, ASTNode.JAVADOC);
            methodDeclaration.setJavadoc(doc);
        }
    }
    Block block = ast.newBlock();
    methodDeclaration.setBody(block);
    return methodDeclaration;
}

From source file:info.okoshi.visitor.AccessorsGenerateVisitor.java

License:Open Source License

/**
 * Generate getter method.<br>//  w  w w .j  a v a  2s .c o  m
 *
 * @param node
 *          {@link FieldDeclaration} object
 * @param ast
 *          {@link AST} object
 * @param name
 *          name of field variable
 * @return {@link MethodDeclaration} object
 */
@SuppressWarnings("unchecked")
private MethodDeclaration generateGetter(FieldDeclaration node, AST ast, String name) {
    MethodDeclaration getter = ast.newMethodDeclaration();
    if (node.getJavadoc() != null) {
        getter.setJavadoc(createGetterJavadoc(node, ast));
    }
    getter.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));

    Type type = (Type) ASTNode.copySubtree(ast, node.getType());
    getter.setReturnType2(type);
    getter.setName(ast.newSimpleName(getGetterPrefix(type) + StringUtils.capitalize(name)));

    Block block = ast.newBlock();
    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ast.newSimpleName(name));
    block.statements().add(returnStatement);
    getter.setBody(block);
    return getter;
}

From source file:info.okoshi.visitor.AccessorsGenerateVisitor.java

License:Open Source License

/**
 * Generate setter method.<br>/*from w  w  w.ja  va  2  s  . c om*/
 *
 * @param node
 *          {@link FieldDeclaration} object
 * @param ast
 *          {@link AST} object
 * @param name
 *          name of field variable
 * @return {@link MethodDeclaration} object
 */
@SuppressWarnings("unchecked")
private MethodDeclaration generateSetter(FieldDeclaration node, AST ast, String name) {
    MethodDeclaration setter = ast.newMethodDeclaration();
    if (node.getJavadoc() != null) {
        setter.setJavadoc(createSetterJavadoc(node, ast, name));
    }
    setter.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
    setter.setName(ast.newSimpleName("set" + StringUtils.capitalize(name)));

    SingleVariableDeclaration singleVariable = ast.newSingleVariableDeclaration();
    singleVariable.setType((Type) ASTNode.copySubtree(ast, node.getType()));
    singleVariable.setName(ast.newSimpleName(name));
    setter.parameters().add(singleVariable);

    Block block = ast.newBlock();
    Assignment assignment = ast.newAssignment();
    FieldAccess fieldAccess = ast.newFieldAccess();
    fieldAccess.setExpression(ast.newThisExpression());
    fieldAccess.setName(ast.newSimpleName(name));
    assignment.setLeftHandSide(fieldAccess);
    assignment.setOperator(Assignment.Operator.ASSIGN);
    assignment.setRightHandSide(ast.newSimpleName(name));
    block.statements().add(ast.newExpressionStatement(assignment));
    setter.setBody(block);

    return setter;
}