Example usage for org.eclipse.jdt.core.dom LambdaExpression setParentheses

Introduction

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

Prototype

public void setParentheses(boolean hasParentheses) 

Source Link

Document

Sets whether this lambda expression has parentheses around its parameters or not.

Usage

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  w  w  .  jav a 2  s  .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);
}

---