Example usage for org.eclipse.jdt.core.dom Block statements

List of usage examples for org.eclipse.jdt.core.dom Block statements

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. Block
  6. statements

Introduction

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

Prototype

ASTNode.NodeList statements

To view the source code for org.eclipse.jdt.core.dom Block statements.

Click Source Link

Document

The list of statements (element type: Statement ).

Usage

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

License:Apache License

/**
 * Generate getter method./*w w  w.  j a v  a2 s .  c o  m*/
 * 
 * @param clazz
 *            UML2 classifier
 * @param ast
 *            JDT AST tree
 * @param ed
 *            EnumDeclaration JDT
 */
@SuppressWarnings("unchecked")
public void generateGetterMethod(Classifier clazz, AST ast, EnumDeclaration ed) {
    EList<Property> properties = clazz.getAttributes();
    for (Property property : properties) {
        Type type = property.getType();
        logger.log(Level.FINE, "Class: " + clazz.getName() + " - " + "Property: " + property.getName() + " - "
                + "Property Upper: " + property.getUpper() + " - " + "Property Lower: " + property.getLower());
        String umlTypeName = type.getName();
        String umlQualifiedTypeName = type.getQualifiedName();
        MethodDeclaration methodDeclaration = interfaceGenerator.generateGetterMethod(ast, ed, property,
                umlTypeName, umlQualifiedTypeName, sourceDirectoryPackageName);

        // Public
        methodDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));

        // Content of getter method
        Block block = ast.newBlock();
        ReturnStatement returnStatement = ast.newReturnStatement();
        SimpleName simpleName = ast.newSimpleName(property.getName());
        returnStatement.setExpression(simpleName);
        block.statements().add(returnStatement);
        methodDeclaration.setBody(block);
    }
}

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

License:Apache License

/**
 * Generate constructor./*from w w  w.  j  av  a  2  s .c om*/
 * 
 * @param clazz
 *            UML2 class
 * @param ast
 *            JDT AST
 * @param ed
 *            EnumDeclaration JDT
 */
@SuppressWarnings("unchecked")
public void generateConstructor(Classifier clazz, AST ast, EnumDeclaration ed) {
    // Constructor
    MethodDeclaration md = ast.newMethodDeclaration();
    md.setConstructor(true);
    md.setName(ast.newSimpleName(clazz.getName()));
    md.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
    ed.bodyDeclarations().add(md);

    // We need to build contructor parameters for each properties
    generateContructorParameters(clazz, ast, md);

    // Content of constructor
    Block block = ast.newBlock();

    EList<Property> properties = clazz.getAttributes();
    for (Property property : properties) {
        logger.log(Level.FINE, "Class: " + clazz.getName() + " - " + "Property: " + property.getName() + " - "
                + "Property Upper: " + property.getUpper() + " - " + "Property Lower: " + property.getLower());

        // Left expression
        SimpleName simpleName = ast.newSimpleName(property.getName());
        ThisExpression thisExpression = ast.newThisExpression();
        FieldAccess fieldAccess = ast.newFieldAccess();
        fieldAccess.setName(simpleName);
        fieldAccess.setExpression(thisExpression);

        // Right expression
        SimpleName parameter = ast.newSimpleName(property.getName());

        Assignment assignment = ast.newAssignment();
        assignment.setOperator(org.eclipse.jdt.core.dom.Assignment.Operator.ASSIGN);
        assignment.setLeftHandSide(fieldAccess);
        assignment.setRightHandSide(parameter);

        // Expression
        ExpressionStatement expressionStatement = ast.newExpressionStatement(assignment);

        block.statements().add(expressionStatement);
    }

    // Set Body to MethodDeclaration
    md.setBody(block);
}

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

License:Apache License

@SuppressWarnings("unchecked")
public void generateConstructorWithParams(Classifier clazz, AST ast, TypeDeclaration td, String[] varTypes,
        String[] varNames) {/* www.j  a  v a  2  s . c o m*/
    MethodDeclaration constructor = ast.newMethodDeclaration();
    constructor.setConstructor(true);
    constructor.setName(ast.newSimpleName(clazz.getName()));
    constructor.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));

    for (int index = 0; index < varTypes.length; index++) {
        SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration();
        variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName(varTypes[index])));
        variableDeclaration.setName(ast.newSimpleName(varNames[index]));
        constructor.parameters().add(variableDeclaration);
    }

    Block block = ast.newBlock();
    SuperConstructorInvocation constructorInvocation = ast.newSuperConstructorInvocation();

    for (int index = 0; index < varNames.length; index++) {
        constructorInvocation.arguments().add(ast.newSimpleName(varNames[index]));
    }

    block.statements().add(constructorInvocation);
    constructor.setBody(block);
    td.bodyDeclarations().add(constructor);
}

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  w ww  .j a va2s.c  om*/
    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 createInternalMethod(final TypeDeclaration parentTypeDeclaration, final MethodInformation m,
        final MethodDeclaration md) {
    final AST ast = md.getAST();

    final Block body = ast.newBlock();
    md.setBody(body);/*from w  ww.jav  a  2s  .c o m*/

    /*
     * return this.connection.call(CallRequest.of("io.systemd.network.List"))
     * .thenApply(cr -> { check(cr);
     *
     * final Iterator<JsonElement> i = cr.getParameters().values().iterator();
     *
     * return asList( this.varlink .fromJson( Netdev[].class, i.next())); }); }
     */

    // add arguments

    if (!m.getParameters().isEmpty()) {

        // code: Map<String,Object> parameters = new HashMap<> ();

        final VariableDeclarationFragment parameters = ast.newVariableDeclarationFragment();
        parameters.setName(ast.newSimpleName("parameters"));

        final VariableDeclarationStatement decl = ast.newVariableDeclarationStatement(parameters);
        body.statements().add(decl);
        final ParameterizedType map = ast.newParameterizedType(ast.newSimpleType(ast.newName("java.util.Map")));
        map.typeArguments().add(ast.newSimpleType(ast.newName("java.lang.String")));
        map.typeArguments().add(ast.newSimpleType(ast.newName("java.lang.Object")));

        decl.setType(map);

        final ClassInstanceCreation init = ast.newClassInstanceCreation();
        init.setType(ast.newParameterizedType(ast.newSimpleType(ast.newName("java.util.HashMap"))));
        init.arguments().add(ast.newNumberLiteral(Integer.toString(m.getParameters().size())));
        parameters.setInitializer(init);

        for (final String argName : m.getParameters().keySet()) {
            final MethodInvocation mi = ast.newMethodInvocation();
            mi.setExpression(ast.newSimpleName("parameters"));
            mi.setName(ast.newSimpleName("put"));

            mi.arguments().add(JdtHelper.newStringLiteral(ast, argName));
            mi.arguments().add(ast.newSimpleName(argName));
        }

    }

    // return

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

    final MethodInvocation mi = ast.newMethodInvocation();
    mi.setName(ast.newSimpleName("call"));
    final FieldAccess fa = ast.newFieldAccess();
    fa.setExpression(ast.newThisExpression());
    fa.setName(ast.newSimpleName("connection"));
    mi.setExpression(fa);

    final MethodInvocation cr = ast.newMethodInvocation();
    cr.setExpression(ast.newName("de.dentrassi.varlink.spi.CallRequest"));
    cr.setName(ast.newSimpleName("of"));
    cr.arguments().add(newStringLiteral(ast, m.getInterface().getName() + "." + toUpperFirst(m.getName())));

    if (!m.getParameters().isEmpty()) {
        cr.arguments().add(ast.newSimpleName("parameters"));
    }

    mi.arguments().add(cr);

    final MethodInvocation thenApply = ast.newMethodInvocation();
    thenApply.setName(ast.newSimpleName("thenApply"));
    thenApply.setExpression(mi);

    // add transformation

    final LambdaExpression le = ast.newLambdaExpression();
    le.setParentheses(false);
    thenApply.arguments().add(le);
    final VariableDeclarationFragment p = ast.newVariableDeclarationFragment();
    p.setName(ast.newSimpleName("result"));
    le.parameters().add(p);
    final Block transform = ast.newBlock();
    le.setBody(transform);

    {
        // check result

        final MethodInvocation check = ast.newMethodInvocation();
        check.setName(ast.newSimpleName("checkError"));
        transform.statements().add(ast.newExpressionStatement(check));
        check.arguments().add(ast.newSimpleName("result"));
    }

    if (m.getReturnTypes().isEmpty()) {

        final ReturnStatement transformRet = ast.newReturnStatement();
        transformRet.setExpression(ast.newNullLiteral());
        transform.statements().add(transformRet);

    } else {

        final int returns = m.getReturnTypes().size();

        if (returns > 0) {

            // return this.varlink.fromJson(DriveCondition.class, result.getParameters());
            // return this.varlink.fromJson(DriveCondition.class,
            // result.getFirstParameter());

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

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

            // FIXME: add to parent
            {
                final ParameterizedType ttt = ast
                        .newParameterizedType(ast.newSimpleType(ast.newName(TYPE_TOKEN_TYPE_NAME)));

                ttt.typeArguments().add(m.createMainReturnType(ast));
                final ClassInstanceCreation tt = ast.newClassInstanceCreation();
                tt.setType(JdtHelper.copyNode(ast, ttt));

                final AnonymousClassDeclaration decl = ast.newAnonymousClassDeclaration();
                tt.setAnonymousClassDeclaration(decl);

                final MethodInvocation getType = ast.newMethodInvocation();
                getType.setExpression(tt);
                getType.setName(ast.newSimpleName("getType"));

                final VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
                vdf.setName(ast.newSimpleName(m.getName() + "_returnTypeToken"));
                vdf.setInitializer(getType);
                final FieldDeclaration fd = ast.newFieldDeclaration(vdf);
                fd.setType(ast.newSimpleType(ast.newName("java.lang.reflect.Type")));
                make(fd, PRIVATE_KEYWORD, FINAL_KEYWORD, STATIC_KEYWORD);

                parentTypeDeclaration.bodyDeclarations().add(fd);
            }

            fromJson.arguments().add(ast.newSimpleName(m.getName() + "_returnTypeToken"));

            // json fragment

            final MethodInvocation fragment = ast.newMethodInvocation();
            if (returns == 1) {
                fragment.setName(ast.newSimpleName("getFirstParameter"));
            } else {
                fragment.setName(ast.newSimpleName("getParameters"));
            }
            fragment.setExpression(ast.newSimpleName("result"));

            fromJson.arguments().add(fragment);

            // return

            final ReturnStatement transformRet = ast.newReturnStatement();
            transformRet.setExpression(fromJson);
            transform.statements().add(transformRet);
        }

        // FIXME: handle return type

        // FIXME: handle n

    }

    // set return

    ret.setExpression(thenApply);
}

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

License:Open Source License

@SuppressWarnings("unchecked")
private void createImplFactory(final AST ast, final TypeDeclaration td) {

    final TypeDeclaration ftd = ast.newTypeDeclaration();
    td.bodyDeclarations().add(ftd);// ww w. j a v a2  s . co m
    ftd.setName(ast.newSimpleName("Factory"));
    make(ftd, PUBLIC_KEYWORD, STATIC_KEYWORD);

    ftd.superInterfaceTypes().add(ast.newSimpleType(ast.newName("de.dentrassi.varlink.spi.Factory")));

    /*
     *
     * @Override public <T> T create(final VarlinkImpl varlink, final Class<T>
     * clazz, final Connection connection)
     */

    final MethodDeclaration md = ast.newMethodDeclaration();
    ftd.bodyDeclarations().add(md);
    md.setName(ast.newSimpleName("create"));
    md.setReturnType2(ast.newSimpleType(ast.newName("T")));
    make(md, PUBLIC_KEYWORD);
    addSimpleAnnotation(md, "Override");

    final TypeParameter tp = ast.newTypeParameter();
    tp.setName(ast.newSimpleName("T"));
    md.typeParameters().add(tp);

    final ParameterizedType clazz = ast.newParameterizedType(ast.newSimpleType(ast.newName("Class")));

    clazz.typeArguments().add(ast.newSimpleType(ast.newName("T")));

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

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

    // return clazz.cast(new Impl(varlink,connection));

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

    final MethodInvocation cast = ast.newMethodInvocation();
    cast.setName(ast.newSimpleName("cast"));
    cast.setExpression(ast.newSimpleName("clazz"));

    ret.setExpression(cast);

    final ClassInstanceCreation newImpl = ast.newClassInstanceCreation();
    newImpl.setType(ast.newSimpleType(ast.newName(td.getName().getIdentifier())));
    cast.arguments().add(newImpl);

    newImpl.arguments().add(ast.newSimpleName("connection"));
    newImpl.arguments().add(ast.newSimpleName("varlink"));
}

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 w  w  .ja v  a  2  s  .c o 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:de.dentrassi.varlink.generator.JdtGenerator.java

License:Open Source License

@SuppressWarnings("unchecked")
private void createType(final TypeDeclaration parent, final String parentName, final TypeAliasDefinition type) {
    final AST ast = parent.getAST();

    if (type instanceof de.dentrassi.varlink.idl.varlinkIdl.Object) {

        final TypeDeclaration td = ast.newTypeDeclaration();
        parent.bodyDeclarations().add(td);

        td.setName(ast.newSimpleName(toUpperFirst(parentName)));
        make(td, PUBLIC_KEYWORD, STATIC_KEYWORD);

        final de.dentrassi.varlink.idl.varlinkIdl.Object o = (de.dentrassi.varlink.idl.varlinkIdl.Object) type;

        for (final Field field : o.getFields()) {

            final String name = toLowerFirst(field.getName());

            // create enum type

            if (field.getType() instanceof de.dentrassi.varlink.idl.varlinkIdl.Enum) {
                final de.dentrassi.varlink.idl.varlinkIdl.Enum en = (de.dentrassi.varlink.idl.varlinkIdl.Enum) field
                        .getType();// www. ja v a2  s  .co  m
                createEnum(td, toUpperFirst(name), en.getFields());
            }

            // created nested type
            if (field.getType() instanceof Object) {
                createType(td, field.getName(), (Object) field.getType());
            }

            // create field

            {
                final VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
                vdf.setName(ast.newSimpleName(name));
                final FieldDeclaration fd = ast.newFieldDeclaration(vdf);
                fd.setType(asType(ast, null, field));
                make(fd, PRIVATE_KEYWORD);

                td.bodyDeclarations().add(fd);
            }

            // create getter

            {
                final MethodDeclaration md = createGetter(ast, asType(ast, null, field), name);
                td.bodyDeclarations().add(md);
            }

            // create setter

            {
                final MethodDeclaration md = ast.newMethodDeclaration();
                md.setName(ast.newSimpleName("set" + toUpperFirst(name)));
                td.bodyDeclarations().add(md);
                make(md, PUBLIC_KEYWORD);

                final SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
                svd.setName(ast.newSimpleName(name));
                svd.setType(asType(ast, null, field));

                md.parameters().add(svd);

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

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

                final Assignment ass = ast.newAssignment();
                ass.setLeftHandSide(fa);
                ass.setRightHandSide(ast.newSimpleName(name));

                body.statements().add(ast.newExpressionStatement(ass));

            }

        }

    } else if (type instanceof de.dentrassi.varlink.idl.varlinkIdl.Enum) {

        // FIXME: create enums
    }
}

From source file:de.dentrassi.varlink.generator.util.JdtHelper.java

License:Open Source License

public static void createThisAssignment(final Block body, final String name) {
    final AST ast = body.getAST();
    final Assignment as = ast.newAssignment();
    final FieldAccess fa = ast.newFieldAccess();
    fa.setExpression(ast.newThisExpression());
    fa.setName(ast.newSimpleName(name));
    as.setLeftHandSide(fa);//  ww w.j  a  v  a 2 s  .c  o m
    as.setRightHandSide(ast.newSimpleName(name));
    body.statements().add(ast.newExpressionStatement(as));
}

From source file:de.dentrassi.varlink.generator.util.JdtHelper.java

License:Open Source License

public static MethodDeclaration createGetter(final AST ast, final Type type, final String name) {
    final MethodDeclaration md = ast.newMethodDeclaration();
    md.setName(ast.newSimpleName("get" + Names.toUpperFirst(name)));
    make(md, PUBLIC_KEYWORD);/*from  w ww .  j a  v a 2s  .c o m*/

    md.setReturnType2(type);

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

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

    final FieldAccess fa = ast.newFieldAccess();
    fa.setExpression(ast.newThisExpression());
    fa.setName(ast.newSimpleName(name));
    ret.setExpression(fa);

    return md;
}