Example usage for org.eclipse.jdt.core.dom TypeLiteral setType

List of usage examples for org.eclipse.jdt.core.dom TypeLiteral setType

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. TypeLiteral
  6. setType

Introduction

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

Prototype

public void setType(Type type)

Source Link

Document

Sets the type in this type literal expression to the given type.

Usage

From source file:com.android.icu4j.srcgen.RunWithAnnotator.java

License:Apache License

private boolean addRunWithAnnotation(CompilationUnit cu, ASTRewrite rewrite, TypeDeclaration type,
        String runnerClass, boolean imported) {

    AST ast = cu.getAST();/*from w w  w. jav a  2s. com*/

    QualifiedName qRunWith = (QualifiedName) ast.newName(RUN_WITH_CLASS_NAME);
    QualifiedName qRunner = (QualifiedName) ast.newName(runnerClass);
    if (!imported) {
        appendImport(cu, rewrite, qRunWith);
        appendImport(cu, rewrite, qRunner);
    }
    String runWithName = qRunWith.getName().getIdentifier();
    String runnerName = qRunner.getName().getIdentifier();

    SingleMemberAnnotation annotation = ast.newSingleMemberAnnotation();
    annotation.setTypeName(ast.newSimpleName(runWithName));

    TypeLiteral junit4Literal = ast.newTypeLiteral();
    junit4Literal.setType(ast.newSimpleType(ast.newSimpleName(runnerName)));
    annotation.setValue(junit4Literal);

    ListRewrite lrw = rewrite.getListRewrite(type, type.getModifiersProperty());
    lrw.insertFirst(annotation, null);

    return imported;
}

From source file:com.google.devtools.j2cpp.translate.Autoboxer.java

License:Open Source License

@Override
public void endVisit(TypeLiteral node) {
    ITypeBinding binding = Types.getTypeBinding(node.getType());
    if (binding.isPrimitive() && !Types.isVoidType(binding)) {
        Type boxedType = Types.makeType(Types.getWrapperType(binding));
        node.setType(boxedType);
    }/*from w  ww  .j a v  a2s .co m*/
}

From source file:com.google.devtools.j2cpp.translate.Rewriter.java

License:Open Source License

/**
 * Convert an array initializer into a init method on the equivalent
 * IOSArray. This init method takes a C array and count, like
 * NSArray.arrayWithObjects:count:. For example, "int[] a = { 1, 2, 3 };"
 * translates to "[IOSIntArray initWithInts:(int[]){ 1, 2, 3 } count:3];".
 *///from  www.  ja  v a 2 s  .c om
private MethodInvocation createIOSArrayInitializer(ITypeBinding arrayType, ArrayInitializer arrayInit) {
    AST ast = arrayInit.getAST();

    int dimensions = arrayType.getDimensions();
    ITypeBinding componentType;
    IOSArrayTypeBinding iosArrayBinding;
    if (dimensions > 2) {
        // This gets resolved into IOSObjectArray, for an array of arrays.
        componentType = iosArrayBinding = Types.resolveArrayType(arrayType);
    } else if (dimensions == 2) {
        // Creates a single-dimension array type.
        componentType = Types.resolveArrayType(arrayType.getElementType());
        iosArrayBinding = Types.resolveArrayType(componentType);
    } else {
        componentType = Types.getTypeBinding(arrayInit).getComponentType();
        iosArrayBinding = Types.resolveArrayType(componentType);
    }

    // Create IOS message.
    MethodInvocation message = ast.newMethodInvocation();
    SimpleName receiver = ast.newSimpleName(iosArrayBinding.getName());
    Types.addBinding(receiver, iosArrayBinding);
    message.setExpression(receiver);
    String methodName = iosArrayBinding.getInitMethod();
    SimpleName messageName = ast.newSimpleName(methodName);
    GeneratedMethodBinding methodBinding = new GeneratedMethodBinding(methodName,
            Modifier.PUBLIC | Modifier.STATIC, iosArrayBinding, iosArrayBinding, false, false, true);
    Types.addBinding(messageName, methodBinding);
    message.setName(messageName);
    Types.addBinding(message, methodBinding);

    // Pass array initializer as C-style array to message.
    @SuppressWarnings("unchecked")
    List<Expression> args = message.arguments(); // safe by definition
    ArrayInitializer newArrayInit = NodeCopier.copySubtree(ast, arrayInit);
    @SuppressWarnings("unchecked")
    List<Expression> exprs = newArrayInit.expressions();
    for (int i = 0; i < exprs.size(); i++) {
        // Convert any elements that are also array initializers.
        Expression expr = exprs.get(i);
        if (expr instanceof ArrayInitializer) {
            exprs.set(i, createIOSArrayInitializer(componentType, (ArrayInitializer) expr));
        }
    }
    args.add(newArrayInit);
    GeneratedVariableBinding argBinding = new GeneratedVariableBinding(arrayType, false, true, null,
            methodBinding);
    methodBinding.addParameter(argBinding);
    NumberLiteral arraySize = ast.newNumberLiteral(Integer.toString(arrayInit.expressions().size()));
    Types.addBinding(arraySize, ast.resolveWellKnownType("int"));
    args.add(arraySize);
    argBinding = new GeneratedVariableBinding(ast.resolveWellKnownType("int"), false, true, null,
            methodBinding);
    methodBinding.addParameter(argBinding);

    // Specify type for object arrays.
    if (iosArrayBinding.getName().equals("IOSObjectArray")) {
        TypeLiteral typeLiteral = ast.newTypeLiteral();
        typeLiteral.setType(Types.makeType(componentType));
        Types.addBinding(typeLiteral, Types.getIOSClass());
        args.add(typeLiteral);
        argBinding = new GeneratedVariableBinding("type", 0, Types.getIOSClass(), false, true, null,
                methodBinding);
        methodBinding.addParameter(argBinding);
    }

    return message;
}

From source file:com.google.devtools.j2objc.translate.ASTFactory.java

License:Apache License

public static TypeLiteral newTypeLiteral(AST ast, ITypeBinding type) {
    TypeLiteral literal = ast.newTypeLiteral();
    literal.setType(newType(ast, type));
    Types.addBinding(literal, type);
    return literal;
}

From source file:com.halware.nakedide.eclipse.ext.annot.utils.AstUtils.java

License:Open Source License

/**
 * Creates an (AST) {@link Literal} expression.
 * //  w ww . j  av  a 2  s  .  c o m
 * @param ast
 * @param value
 * @return
 */
public static Expression createExpression(AST ast, Object value) {
    if (value instanceof String) {
        String stringValue = (String) value;
        StringLiteral newStringLiteral = ast.newStringLiteral();
        newStringLiteral.setLiteralValue(stringValue);
        return newStringLiteral;
    }
    if (value instanceof Boolean) {
        Boolean booleanValue = (Boolean) value;
        return ast.newBooleanLiteral(booleanValue);
    }
    if (value instanceof Number) {
        Number numberValue = (Number) value;
        return ast.newNumberLiteral(numberValue.toString());
    }
    if (value instanceof AstUtils.TypeLiteralValue) {
        AstUtils.TypeLiteralValue classHandle = (AstUtils.TypeLiteralValue) value;
        TypeLiteral newTypeLiteral = ast.newTypeLiteral();

        Name typeName = ast.newName(classHandle.getClassName());
        Type type = ast.newSimpleType(typeName);
        newTypeLiteral.setType(type);
        return newTypeLiteral;
    }
    if (value instanceof AstUtils.QualifiedNameValue) {
        AstUtils.QualifiedNameValue enumMember = (AstUtils.QualifiedNameValue) value;
        Name enumTypeName = ast.newName(enumMember.getName());
        SimpleName enumMemberName = ast.newSimpleName(enumMember.getIdentifier());
        return ast.newQualifiedName(enumTypeName, enumMemberName);
    }
    return ast.newNullLiteral();
}

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

License:Open Source License

private void createHomeImplementation(IProgressMonitor monitor, ICompilationUnit iUnit, String typePackage,
        String name) throws JavaModelException, MalformedTreeException, BadLocationException {
    iUnit.getBuffer().setContents("");
    String source = iUnit.getBuffer().getContents();
    Document document = new Document(source);

    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(iUnit);/*from w  w w.j a  v a2  s  . c om*/

    CompilationUnit unit = (CompilationUnit) parser.createAST(monitor);
    unit.recordModifications();

    AST ast = unit.getAST();

    // Package statement
    PackageDeclaration packageDeclaration = ast.newPackageDeclaration();
    unit.setPackage(packageDeclaration);
    packageDeclaration.setName(ast.newName(typePackage));

    // class declaration
    TypeDeclaration classType = getTypeDeclaration(ast, name + "HomeImpl", false, "IBOHomeImpl", null,
            getHomeImplImports());
    classType.superInterfaceTypes().add(ast.newSimpleType(ast.newSimpleName(name + "Home")));
    addHomeImplImport("com.idega.business.IBOHomeImpl");
    unit.types().add(classType);

    // create() method
    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    if (this.isJDK1_5) {
        MarkerAnnotation annotation = ast.newMarkerAnnotation();
        annotation.setTypeName(ast.newSimpleName("Override"));
        methodConstructor.modifiers().add(annotation);
    }
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    if (this.isJDK1_5) {
        ParameterizedType returnType = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("Class")));
        returnType.typeArguments().add(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setReturnType2(returnType);
    } else {
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName("Class")));
    }
    methodConstructor.setName(ast.newSimpleName("getBeanInterfaceClass"));

    classType.bodyDeclarations().add(methodConstructor);

    Block constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    TypeLiteral typeLiteral = ast.newTypeLiteral();
    typeLiteral.setType(ast.newSimpleType(ast.newSimpleName(name)));

    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(typeLiteral);
    constructorBlock.statements().add(returnStatement);

    // create() method
    methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
    methodConstructor.setName(ast.newSimpleName("create"));
    methodConstructor.thrownExceptions().add(ast.newName("CreateException"));
    addHomeImplImport("javax.ejb.CreateException");
    classType.bodyDeclarations().add(methodConstructor);

    constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    SuperMethodInvocation superMethodInvocation = ast.newSuperMethodInvocation();
    superMethodInvocation.setName(ast.newSimpleName("createIBO"));

    CastExpression ce = ast.newCastExpression();
    ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
    ce.setExpression(superMethodInvocation);

    returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ce);
    constructorBlock.statements().add(returnStatement);

    writeImports(ast, unit, getHomeImplImports());
    commitChanges(iUnit, unit, document);
}

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

License:Open Source License

private void createHomeImplementation(IProgressMonitor monitor, ICompilationUnit iUnit, String typePackage,
        String name) throws JavaModelException, MalformedTreeException, BadLocationException {
    iUnit.getBuffer().setContents("");
    String source = iUnit.getBuffer().getContents();
    Document document = new Document(source);

    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource(iUnit);//from w  ww. j a  v  a2 s.c o  m

    CompilationUnit unit = (CompilationUnit) parser.createAST(monitor);
    unit.recordModifications();

    AST ast = unit.getAST();

    // Package statement
    unit.setPackage(getPackageDeclaration(ast, typePackage));

    // class declaration
    TypeDeclaration classType = getTypeDeclaration(ast, name + "HomeImpl", false, "IDOFactory", null,
            getHomeImplImports());
    classType.superInterfaceTypes().add(ast.newSimpleType(ast.newSimpleName(name + "Home")));
    addHomeImplImport("com.idega.data.IDOFactory");
    unit.types().add(classType);

    // create() method
    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    if (this.isJDK1_5) {
        MarkerAnnotation annotation = ast.newMarkerAnnotation();
        annotation.setTypeName(ast.newSimpleName("Override"));
        methodConstructor.modifiers().add(annotation);
    }
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    if (this.isJDK1_5) {
        ParameterizedType returnType = ast.newParameterizedType(ast.newSimpleType(ast.newSimpleName("Class")));
        returnType.typeArguments().add(ast.newSimpleType(ast.newSimpleName(name + "Home")));
        methodConstructor.setReturnType2(returnType);
    } else {
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName("Class")));
    }
    methodConstructor.setName(ast.newSimpleName("getEntityInterfaceClass"));

    classType.bodyDeclarations().add(methodConstructor);

    Block constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    TypeLiteral typeLiteral = ast.newTypeLiteral();
    typeLiteral.setType(ast.newSimpleType(ast.newSimpleName(name)));

    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(typeLiteral);
    constructorBlock.statements().add(returnStatement);

    // create() method
    methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
    methodConstructor.setName(ast.newSimpleName("create"));
    methodConstructor.thrownExceptions().add(ast.newName("CreateException"));
    addHomeImplImport("javax.ejb.CreateException");
    classType.bodyDeclarations().add(methodConstructor);

    constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    SuperMethodInvocation superMethodInvocation = ast.newSuperMethodInvocation();
    superMethodInvocation.setName(ast.newSimpleName("createIDO"));

    CastExpression ce = ast.newCastExpression();
    ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
    ce.setExpression(superMethodInvocation);

    returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ce);
    constructorBlock.statements().add(returnStatement);

    // findByPrimarKey(Object) method
    methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(false);
    methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
    methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
    methodConstructor.setName(ast.newSimpleName("findByPrimaryKey"));
    methodConstructor.thrownExceptions().add(ast.newName("FinderException"));
    addHomeImplImport("javax.ejb.FinderException");
    classType.bodyDeclarations().add(methodConstructor);

    SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration();
    variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
    variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName("Object")));
    variableDeclaration.setName(ast.newSimpleName("pk"));
    methodConstructor.parameters().add(variableDeclaration);

    constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    superMethodInvocation = ast.newSuperMethodInvocation();
    superMethodInvocation.setName(ast.newSimpleName("findByPrimaryKeyIDO"));
    superMethodInvocation.arguments().add(ast.newSimpleName("pk"));

    ce = ast.newCastExpression();
    ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
    ce.setExpression(superMethodInvocation);

    returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ce);
    constructorBlock.statements().add(returnStatement);

    if (this.isLegacyEntity) {
        // createLegacy() method
        methodConstructor = ast.newMethodDeclaration();
        methodConstructor.setConstructor(false);
        methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setName(ast.newSimpleName("createLegacy"));
        classType.bodyDeclarations().add(methodConstructor);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        TryStatement tryStatement = ast.newTryStatement();
        constructorBlock.statements().add(tryStatement);
        Block tryBlock = ast.newBlock();
        tryStatement.setBody(tryBlock);

        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("create"));

        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(mi);
        tryBlock.statements().add(returnStatement);

        CatchClause catchClause = ast.newCatchClause();
        tryStatement.catchClauses().add(catchClause);
        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("CreateException"))));
        variableDeclaration.setName(ast.newSimpleName("ce"));
        catchClause.setException(variableDeclaration);
        Block catchBlock = ast.newBlock();
        catchClause.setBody(catchBlock);

        ClassInstanceCreation cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("RuntimeException")));
        mi = ast.newMethodInvocation();
        mi.setExpression(ast.newSimpleName("ce"));
        mi.setName(ast.newSimpleName("getMessage"));
        cc.arguments().add(mi);

        ThrowStatement throwStatement = ast.newThrowStatement();
        throwStatement.setExpression(cc);
        catchBlock.statements().add(throwStatement);

        // findByPrimarKey(int) method
        methodConstructor = ast.newMethodDeclaration();
        methodConstructor.setConstructor(false);
        methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setName(ast.newSimpleName("findByPrimaryKey"));
        methodConstructor.thrownExceptions().add(ast.newName("FinderException"));
        classType.bodyDeclarations().add(methodConstructor);

        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT));
        variableDeclaration.setName(ast.newSimpleName("id"));
        methodConstructor.parameters().add(variableDeclaration);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        superMethodInvocation = ast.newSuperMethodInvocation();
        superMethodInvocation.setName(ast.newSimpleName("findByPrimaryKeyIDO"));
        superMethodInvocation.arguments().add(ast.newSimpleName("id"));

        ce = ast.newCastExpression();
        ce.setType(ast.newSimpleType(ast.newSimpleName(name)));
        ce.setExpression(superMethodInvocation);

        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(ce);
        constructorBlock.statements().add(returnStatement);

        // findByPrimarKeyLegacy(int) method
        methodConstructor = ast.newMethodDeclaration();
        methodConstructor.setConstructor(false);
        methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC));
        methodConstructor.setReturnType2(ast.newSimpleType(ast.newSimpleName(name)));
        methodConstructor.setName(ast.newSimpleName("findByPrimaryKeyLegacy"));
        methodConstructor.thrownExceptions().add(ast.newName("SQLException"));
        addHomeImplImport("java.sql.SQLException");
        classType.bodyDeclarations().add(methodConstructor);

        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT));
        variableDeclaration.setName(ast.newSimpleName("id"));
        methodConstructor.parameters().add(variableDeclaration);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        tryStatement = ast.newTryStatement();
        constructorBlock.statements().add(tryStatement);
        tryBlock = ast.newBlock();
        tryStatement.setBody(tryBlock);

        mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("findByPrimaryKey"));
        mi.arguments().add(ast.newSimpleName("id"));

        returnStatement = ast.newReturnStatement();
        returnStatement.setExpression(mi);
        tryBlock.statements().add(returnStatement);

        catchClause = ast.newCatchClause();
        tryStatement.catchClauses().add(catchClause);
        variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
        variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("FinderException"))));
        variableDeclaration.setName(ast.newSimpleName("fe"));
        catchClause.setException(variableDeclaration);
        catchBlock = ast.newBlock();
        catchClause.setBody(catchBlock);

        cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("SQLException")));
        mi = ast.newMethodInvocation();
        mi.setExpression(ast.newSimpleName("fe"));
        mi.setName(ast.newSimpleName("getMessage"));
        cc.arguments().add(mi);

        throwStatement = ast.newThrowStatement();
        throwStatement.setExpression(cc);
        catchBlock.statements().add(throwStatement);
    }

    MethodFilter[] validFilter = { new MethodFilter(WizardConstants.EJB_CREATE_START, MethodFilter.TYPE_PREFIX),
            new MethodFilter(WizardConstants.EJB_HOME_START, MethodFilter.TYPE_PREFIX),
            new MethodFilter(WizardConstants.EJB_FIND_START, MethodFilter.TYPE_PREFIX) };
    List methods = filterMethods(getType().getMethods(), validFilter, null);
    for (Iterator iter = methods.iterator(); iter.hasNext();) {
        IMethod method = (IMethod) iter.next();
        String fullMethodName = method.getElementName();
        String methodName = cutAwayEJBSuffix(fullMethodName);
        String[] parameterNames = method.getParameterNames();

        String returnType = method.getReturnType();
        if (fullMethodName.startsWith(WizardConstants.EJB_FIND_START)
                || fullMethodName.startsWith(WizardConstants.EJB_CREATE_START)) {
            if (!(Signature.getSimpleName(Signature.toString(method.getReturnType()))
                    .indexOf(Signature.getSimpleName("java.util.Collection")) != -1)
                    && !(Signature.getSimpleName(Signature.toString(method.getReturnType()))
                            .indexOf(Signature.getSimpleName("java.util.Set")) != -1)) {
                returnType = name;
            }
        }
        if (!returnType.equals(name)) {
            returnType = getReturnType(returnType);
        }

        methodConstructor = getMethodDeclaration(ast, method, methodName, returnType, getHomeImplImports(),
                false);
        classType.bodyDeclarations().add(methodConstructor);

        constructorBlock = ast.newBlock();
        methodConstructor.setBody(constructorBlock);

        constructorBlock.statements().add(getIDOCheckOutStatement(ast, getHomeImplImports()));

        if (fullMethodName.startsWith(WizardConstants.EJB_FIND_START)) {
            if (Signature.getSimpleName(Signature.toString(method.getReturnType()))
                    .indexOf(Signature.getSimpleName("java.util.Collection")) != -1) {
                constructorBlock.statements().add(
                        getDataCollectingStatement(ast, returnType, "ids", fullMethodName, parameterNames));
                constructorBlock.statements().add(getIDOCheckInStatement(ast));
                constructorBlock.statements()
                        .add(getObjectReturnStatement(ast, "getEntityCollectionForPrimaryKeys", "ids"));
            } else if (Signature.getSimpleName(Signature.toString(method.getReturnType()))
                    .indexOf(Signature.getSimpleName("java.util.Set")) != -1) {
                constructorBlock.statements().add(
                        getDataCollectingStatement(ast, returnType, "ids", fullMethodName, parameterNames));
                constructorBlock.statements().add(getIDOCheckInStatement(ast));
                constructorBlock.statements()
                        .add(getObjectReturnStatement(ast, "getEntitySetForPrimaryKeys", "ids"));
            } else {
                constructorBlock.statements()
                        .add(getDataCollectingStatement(ast, "Object", "pk", fullMethodName, parameterNames));
                constructorBlock.statements().add(getIDOCheckInStatement(ast));
                constructorBlock.statements().add(getObjectReturnStatement(ast, "findByPrimaryKey", "pk"));
            }
        } else if (fullMethodName.startsWith(WizardConstants.EJB_HOME_START)) {
            constructorBlock.statements().add(
                    getDataCollectingStatement(ast, returnType, "theReturn", fullMethodName, parameterNames));
            constructorBlock.statements().add(getIDOCheckInStatement(ast));
            constructorBlock.statements().add(getPrimitiveReturnStatement(ast, "theReturn"));
        } else if (fullMethodName.startsWith(WizardConstants.EJB_CREATE_START)) {
            constructorBlock.statements()
                    .add(getDataCollectingStatement(ast, "Object", "pk", fullMethodName, parameterNames));

            ce = ast.newCastExpression();
            ce.setType(ast.newSimpleType(ast.newSimpleName(getType().getTypeQualifiedName())));
            ce.setExpression(ast.newSimpleName("entity"));

            ParenthesizedExpression pe = ast.newParenthesizedExpression();
            pe.setExpression(ce);
            MethodInvocation mi = ast.newMethodInvocation();
            mi.setExpression(pe);
            mi.setName(ast.newSimpleName("ejbPostCreate"));
            constructorBlock.statements().add(ast.newExpressionStatement(mi));

            constructorBlock.statements().add(getIDOCheckInStatement(ast));

            TryStatement tryStatement = ast.newTryStatement();
            constructorBlock.statements().add(tryStatement);
            Block tryBlock = ast.newBlock();
            tryStatement.setBody(tryBlock);

            mi = ast.newMethodInvocation();
            mi.setName(ast.newSimpleName("findByPrimaryKey"));
            mi.arguments().add(ast.newSimpleName("pk"));

            returnStatement = ast.newReturnStatement();
            returnStatement.setExpression(mi);
            tryBlock.statements().add(returnStatement);

            CatchClause catchClause = ast.newCatchClause();
            tryStatement.catchClauses().add(catchClause);
            variableDeclaration = ast.newSingleVariableDeclaration();
            variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
            variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("FinderException"))));
            variableDeclaration.setName(ast.newSimpleName("fe"));
            catchClause.setException(variableDeclaration);
            Block catchBlock = ast.newBlock();
            catchClause.setBody(catchBlock);

            ClassInstanceCreation cc = ast.newClassInstanceCreation();
            cc.setType(ast.newSimpleType(ast.newSimpleName("IDOCreateException")));
            addHomeImplImport("com.idega.data.IDOCreateException");
            cc.arguments().add(ast.newSimpleName(("fe")));

            ThrowStatement throwStatement = ast.newThrowStatement();
            throwStatement.setExpression(cc);
            catchBlock.statements().add(throwStatement);

            catchClause = ast.newCatchClause();
            tryStatement.catchClauses().add(catchClause);
            variableDeclaration = ast.newSingleVariableDeclaration();
            variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE));
            variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(("Exception"))));
            variableDeclaration.setName(ast.newSimpleName("e"));
            catchClause.setException(variableDeclaration);
            catchBlock = ast.newBlock();
            catchClause.setBody(catchBlock);

            cc = ast.newClassInstanceCreation();
            cc.setType(ast.newSimpleType(ast.newSimpleName("IDOCreateException")));
            cc.arguments().add(ast.newSimpleName(("e")));

            throwStatement = ast.newThrowStatement();
            throwStatement.setExpression(cc);
            catchBlock.statements().add(throwStatement);
        }
    }

    writeImports(ast, unit, getHomeImplImports());
    commitChanges(iUnit, unit, document);
}

From source file:de.dentrassi.varlink.generator.JdtGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void createImpl(final AST ast, final CompilationUnit cu, final Interface iface, final String name) {

    // create type

    final String implName = name + "Impl";

    final TypeDeclaration td = ast.newTypeDeclaration();
    cu.types().add(td);//from   ww  w  .  ja va2s .co m
    td.setName(ast.newSimpleName(implName));

    make(td, PUBLIC_KEYWORD);

    final Type parentType = ast.newSimpleType(ast.newName(name));
    td.superInterfaceTypes().add(parentType);

    // create factory

    createImplFactory(ast, td);

    // create fields

    createField(td, "de.dentrassi.varlink.spi.Connection", "connection", PRIVATE_KEYWORD, FINAL_KEYWORD);
    createField(td, "de.dentrassi.varlink.internal.VarlinkImpl", "varlink", PRIVATE_KEYWORD, FINAL_KEYWORD);

    // create constructor

    final MethodDeclaration ctor = ast.newMethodDeclaration();
    td.bodyDeclarations().add(ctor);

    ctor.setConstructor(true);
    ctor.setName(ast.newSimpleName(implName));
    make(ctor, PRIVATE_KEYWORD);

    createParameter(ctor, "de.dentrassi.varlink.spi.Connection", "connection", FINAL_KEYWORD);
    createParameter(ctor, "de.dentrassi.varlink.internal.VarlinkImpl", "varlink", FINAL_KEYWORD);

    // constructor body
    {
        final Block body = ast.newBlock();
        ctor.setBody(body);

        createThisAssignment(body, "connection");
        createThisAssignment(body, "varlink");
    }

    // error mapper

    {
        final MethodDeclaration md = ast.newMethodDeclaration();
        make(md, PUBLIC_KEYWORD);
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("checkError"));
        createParameter(md, "de.dentrassi.varlink.spi.CallResponse", "response", FINAL_KEYWORD);

        final Block body = ast.newBlock();
        md.setBody(body);

        final MethodInvocation mi = ast.newMethodInvocation();
        mi.setExpression(ast.newName("de.dentrassi.varlink.spi.Errors"));
        mi.setName(ast.newSimpleName("checkErrors"));
        mi.arguments().add(ast.newSimpleName("response"));

        final ExpressionMethodReference ref = ast.newExpressionMethodReference();
        ref.setExpression(ast.newThisExpression());
        ref.setName(ast.newSimpleName("mapError"));
        mi.arguments().add(ref);

        body.statements().add(ast.newExpressionStatement(mi));
    }

    {
        final MethodDeclaration md = ast.newMethodDeclaration();
        make(md, PUBLIC_KEYWORD);
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("mapError"));
        createParameter(md, "java.lang.String", "error", FINAL_KEYWORD);
        createParameter(md, "de.dentrassi.varlink.spi.CallResponse", "response", FINAL_KEYWORD);
        md.setReturnType2(ast.newSimpleType(ast.newName("java.lang.RuntimeException")));

        final Block body = ast.newBlock();
        md.setBody(body);

        final SwitchStatement sw = ast.newSwitchStatement();
        body.statements().add(sw);
        sw.setExpression(ast.newSimpleName("error"));

        errors(iface).forEach(error -> {
            final String errorName = errorTypeName(error);
            final String fullErrorName = iface.getName() + "." + errorName;

            final SwitchCase sc = ast.newSwitchCase();
            sc.setExpression(JdtHelper.newStringLiteral(ast, fullErrorName));
            sw.statements().add(sc);

            final FieldAccess fa = ast.newFieldAccess();
            fa.setExpression(ast.newThisExpression());
            fa.setName(ast.newSimpleName("varlink"));

            final MethodInvocation fromJson = ast.newMethodInvocation();
            fromJson.setExpression(fa);
            fromJson.setName(ast.newSimpleName("fromJson"));

            // type name

            final TypeLiteral typeLiteral = ast.newTypeLiteral();
            typeLiteral.setType(ast.newSimpleType(ast.newName(errorName + ".Parameters")));

            fromJson.arguments().add(typeLiteral);

            // parameters

            final MethodInvocation parameters = ast.newMethodInvocation();
            parameters.setExpression(ast.newSimpleName("response"));
            parameters.setName(ast.newSimpleName("getParameters"));
            fromJson.arguments().add(parameters);

            // new exception

            final ClassInstanceCreation cic = ast.newClassInstanceCreation();
            cic.setType(ast.newSimpleType(ast.newName(errorName)));
            cic.arguments().add(fromJson);

            // return

            final ReturnStatement ret = ast.newReturnStatement();
            ret.setExpression(cic);
            sw.statements().add(ret);
        });

        {
            final SwitchCase sc = ast.newSwitchCase();
            sc.setExpression(null);
            sw.statements().add(sc);
            final ReturnStatement ret = ast.newReturnStatement();
            ret.setExpression(ast.newNullLiteral());
            sw.statements().add(ret);
        }

    }

    // async creator

    /*
     * @Override public Async async() { return new Async() {
     *
     * @Override public CompletableFuture<List<Netdev>> list() { return
     * executeList(); } }; }
     */

    {
        final MethodDeclaration md = ast.newMethodDeclaration();
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("async"));
        addSimpleAnnotation(md, "Override");
        make(md, PUBLIC_KEYWORD);

        md.setReturnType2(ast.newSimpleType(ast.newName("Async")));

        final Block body = ast.newBlock();
        md.setBody(body);

        // inner class

        final ReturnStatement ret = ast.newReturnStatement();
        body.statements().add(ret);

        final ClassInstanceCreation cic = ast.newClassInstanceCreation();
        cic.setType(ast.newSimpleType(ast.newName("Async")));
        ret.setExpression(cic);

        final AnonymousClassDeclaration acc = ast.newAnonymousClassDeclaration();
        cic.setAnonymousClassDeclaration(acc);

        forMethods(ast, iface, (m, amd) -> {

            acc.bodyDeclarations().add(amd);

            amd.setName(ast.newSimpleName(m.getName()));
            make(amd, PUBLIC_KEYWORD);
            makeAsync(amd);

            final Block asyncBody = ast.newBlock();
            amd.setBody(asyncBody);

            final ReturnStatement asyncRet = ast.newReturnStatement();
            asyncBody.statements().add(asyncRet);

            final MethodInvocation mi = ast.newMethodInvocation();
            mi.setName(ast.newSimpleName(internalMethodName(m.getName())));

            for (final String argName : m.getParameters().keySet()) {
                mi.arguments().add(ast.newSimpleName(argName));
            }

            asyncRet.setExpression(mi);
        });

    }

    // internal methods

    forMethods(ast, iface, (m, md) -> {
        make(md, PROTECTED_KEYWORD);
        td.bodyDeclarations().add(md);
        md.setName(ast.newSimpleName(internalMethodName(m.getName())));
        makeAsync(md);
        createInternalMethod(td, m, md);
    });

}

From source file:de.dentrassi.varlink.generator.JdtGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void createInterface(final AST ast, final CompilationUnit cu, final Interface iface,
        final String name) {

    final TypeDeclaration td = ast.newTypeDeclaration();
    cu.types().add(td);/* w  ww  . j  av a  2  s  .  co m*/
    td.setInterface(true);
    td.setName(ast.newSimpleName(name));

    make(td, PUBLIC_KEYWORD);

    final NormalAnnotation ann = JdtHelper.addAnnotation(td, "de.dentrassi.varlink.spi.Interface");

    {
        final MemberValuePair mvpName = ast.newMemberValuePair();
        ann.values().add(mvpName);
        mvpName.setName(ast.newSimpleName("name"));
        mvpName.setValue(JdtHelper.newStringLiteral(ast, iface.getName()));
    }

    {
        final MemberValuePair mvpFactory = ast.newMemberValuePair();
        ann.values().add(mvpFactory);
        mvpFactory.setName(ast.newSimpleName("factory"));

        final TypeLiteral fn = ast.newTypeLiteral();
        fn.setType(ast.newSimpleType(ast.newName(name + "Impl.Factory")));

        mvpFactory.setValue(fn);
    }

    // create types

    createTypes(td, iface);

    // create errors

    createErrors(td, iface);

    /*
     *
     * public interface Async { public CompletableFuture<List<Netdev>> list(); }
     *
     * public interface Sync { public List<Netdev> list(); }
     *
     * public Async async();
     *
     * public default Sync sync() { return new Sync() {
     *
     * @Override public List<Netdev> list() { return Syncer.await(async().list()); }
     * }; }
     */

    // create async

    {
        // public interface Async { ... }

        final TypeDeclaration async = ast.newTypeDeclaration();
        td.bodyDeclarations().add(async);
        async.setInterface(true);

        make(async, PUBLIC_KEYWORD);
        async.setName(ast.newSimpleName("Async"));

        forMethods(ast, iface, (m, md) -> {
            make(md, PUBLIC_KEYWORD);
            async.bodyDeclarations().add(md);
            makeAsync(md);
        });

        // public Async async();

        final MethodDeclaration md = ast.newMethodDeclaration();
        td.bodyDeclarations().add(md);

        md.setName(ast.newSimpleName("async"));
        make(md, PUBLIC_KEYWORD);

        final Type rt = ast.newSimpleType(ast.newSimpleName("Async"));
        md.setReturnType2(rt);
    }

    // create sync

    {
        // public interface Sync { ... }

        final TypeDeclaration sync = ast.newTypeDeclaration();
        td.bodyDeclarations().add(sync);
        sync.setInterface(true);

        make(sync, PUBLIC_KEYWORD);
        sync.setName(ast.newSimpleName("Sync"));

        // methods

        forMethods(ast, iface, (m, md) -> {
            make(md, PUBLIC_KEYWORD);
            sync.bodyDeclarations().add(md);
        });

        {
            final MethodDeclaration smd = ast.newMethodDeclaration();
            smd.setName(ast.newSimpleName("sync"));
            make(smd, PUBLIC_KEYWORD, DEFAULT_KEYWORD);
            td.bodyDeclarations().add(smd);

            final Block body = ast.newBlock();
            smd.setBody(body);

            final ReturnStatement ret = ast.newReturnStatement();
            body.statements().add(ret);

            final ClassInstanceCreation cic = ast.newClassInstanceCreation();
            cic.setType(ast.newSimpleType(ast.newName("Sync")));
            ret.setExpression(cic);
            smd.setReturnType2(ast.newSimpleType(ast.newName("Sync")));

            final AnonymousClassDeclaration acc = ast.newAnonymousClassDeclaration();
            cic.setAnonymousClassDeclaration(acc);

            forMethods(ast, iface, (m, md) -> {

                make(md, PUBLIC_KEYWORD);
                acc.bodyDeclarations().add(md);

                final Block mbody = ast.newBlock();
                md.setBody(mbody);

                // return Syncer.await(async().list());

                final MethodInvocation await = ast.newMethodInvocation();

                await.setExpression(ast.newName("de.dentrassi.varlink.spi.Syncer"));
                await.setName(ast.newSimpleName("await"));

                final MethodInvocation asyncCall = ast.newMethodInvocation();
                asyncCall.setName(ast.newSimpleName("async"));

                final MethodInvocation mcall = ast.newMethodInvocation();
                mcall.setName(ast.newSimpleName(m.getName()));
                mcall.setExpression(asyncCall);

                await.arguments().add(mcall);

                // add arguments

                for (final String argName : m.getParameters().keySet()) {
                    mcall.arguments().add(ast.newSimpleName(argName));
                }

                if (m.getReturnTypes().isEmpty()) {
                    mbody.statements().add(ast.newExpressionStatement(await));
                } else {
                    final ReturnStatement rs = ast.newReturnStatement();
                    rs.setExpression(await);
                    mbody.statements().add(rs);
                }

            });
        }

    }

}

From source file:java5totext.input.JDTVisitor.java

License:Open Source License

@Override
public void endVisit(org.eclipse.jdt.core.dom.TypeLiteral node) {
    TypeLiteral element = (TypeLiteral) this.binding.get(node);
    this.initializeNode(element, node);

    if (this.binding.get(node.getType()) != null)
        element.setType((NamedElementRef) this.binding.get(node.getType()));
}