Example usage for org.eclipse.jdt.core.dom AST newThisExpression

Introduction

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

Prototype

public ThisExpression newThisExpression() 

Source Link

Document

Creates and returns a new unparented "this" expression node owned by this AST.

Usage

From source file:cn.ieclipse.adt.ext.jdt.SourceGenerator.java

License:Apache License

private static void rewriteOnCreate(CompilationUnit unit, String dbName, List<String> tableCreators) {
    AST ast = unit.getAST();
    TypeDeclaration type = (TypeDeclaration) unit.types().get(0);
    MethodDeclaration onCreate = getMethod(type, ("onCreate"), null);
    if (onCreate != null) {
        Block methodBlock = ast.newBlock();

        // mOpenHelper = new
        // InlineOpenHelper(this.getContext(),"person.db",null,1);
        Assignment a = ast.newAssignment();
        a.setOperator(Assignment.Operator.ASSIGN);

        a.setLeftHandSide(ast.newSimpleName("mOpenHelper"));

        ClassInstanceCreation cc = ast.newClassInstanceCreation();
        cc.setType(ast.newSimpleType(ast.newSimpleName("SQLiteOpenHelper")));
        ThisExpression thisExp = ast.newThisExpression();
        MethodInvocation mi = ast.newMethodInvocation();
        mi.setName(ast.newSimpleName("getContext"));
        mi.setExpression(thisExp);//  w  ww  .  j  av  a 2  s.c o m
        cc.arguments().add(mi);
        StringLiteral sl = ast.newStringLiteral();
        sl.setLiteralValue(dbName);

        cc.arguments().add(sl);
        cc.arguments().add(ast.newNullLiteral());
        cc.arguments().add(ast.newNumberLiteral("1"));
        a.setRightHandSide(cc);
        methodBlock.statements().add(ast.newExpressionStatement(a));

        AnonymousClassDeclaration acd = ast.newAnonymousClassDeclaration();
        cc.setAnonymousClassDeclaration(acd);
        genInnerSQLiteOpenHelper(acd, ast, tableCreators);

        a = ast.newAssignment();
        a.setOperator(Assignment.Operator.ASSIGN);

        a.setLeftHandSide(ast.newSimpleName("session"));

        ClassInstanceCreation cic = ast.newClassInstanceCreation();
        cic.setType(ast.newSimpleType(ast.newSimpleName("Session")));

        // SingleVariableDeclaration svd =
        // ast.newSingleVariableDeclaration();
        // svd.setName(ast.newSimpleName("mOpenHelper"));
        cic.arguments().add(ast.newSimpleName("mOpenHelper"));
        // vdf.setInitializer(cic);
        a.setRightHandSide(cic);
        // methodBlock.statements().add(vde);
        methodBlock.statements().add(ast.newExpressionStatement(a));

        ReturnStatement returnStmt = ast.newReturnStatement();
        returnStmt.setExpression(ast.newBooleanLiteral(true));
        methodBlock.statements().add(returnStmt);

        onCreate.setBody(methodBlock);
    }
}

---

From source file:com.flamefire.importsmalinames.astutils.RenameVariablesVisitor.java

License:Open Source License

@Override
public boolean visit(SimpleName node) {
    // We have to be inside a method
    if (curMethod == null)
        return false;
    // Only replace variables
    IBinding binding = node.resolveBinding();
    if (binding == null) {
        if ((node.getParent() instanceof LabeledStatement)
                && ((LabeledStatement) node.getParent()).getLabel().equals(node))
            return false;
        if ((node.getParent() instanceof BreakStatement)
                && ((BreakStatement) node.getParent()).getLabel().equals(node))
            return false;
        if (node.getParent() instanceof QualifiedName)
            return false;
        // This may happen
        System.err.println("Detected SimpleName without binding: " + node + "; Parent:" + node.getParent()
                + "\nThis may happen if there are compile errors");
        // return false;
    } else if (binding.getKind() != IBinding.VARIABLE)
        return false;
    // Check if we need to add a "this"
    // Do this if current node is a field and we may replace a variable with
    // its name//from   w  w  w. j ava2 s.c o  m
    AST ast = node.getAST();
    IVariableBinding vBinding = (IVariableBinding) binding;
    // Check for field acceses
    if (vBinding != null && vBinding.isField()) {
        // Add this if necessary
        if (renaming.containsValue(node.toString()) && !(node.getParent() instanceof FieldAccess)
                && !(node.getParent() instanceof QualifiedName)) {
            FieldAccess fa = ast.newFieldAccess();
            fa.setExpression(ast.newThisExpression());
            fa.setName(ast.newSimpleName(node.toString()));
            astRewrite.replace(node, fa, null);
        }
        return false;
    }
    String newName = renaming.get(node.toString());
    if (newName == null || newName == "")
        return false;
    astRewrite.replace(node, ast.newSimpleName(newName), null);
    return false;
}

---

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

License:Apache License

public static ThisExpression newThisExpression(AST ast, ITypeBinding type) {
    ThisExpression node = ast.newThisExpression();
    Types.addBinding(node, type);
    return node;/*from   w  w w . j a v  a 2  s.co m*/
}

---

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

License:Open Source License

private Statement getIDOCheckOutStatement(AST ast, Set imports) {
    VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment();
    vdf.setName(ast.newSimpleName("entity"));
    VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf);
    vds.setType(ast.newSimpleType(ast.newSimpleName("IDOEntity")));
    imports.add("com.idega.data.IDOEntity");

    ThisExpression thisExpression = ast.newThisExpression();
    MethodInvocation mi = ast.newMethodInvocation();
    mi.setExpression(thisExpression);/*from   ww w . j a va 2  s .  c  o m*/
    mi.setName(ast.newSimpleName("idoCheckOutPooledEntity"));
    vdf.setInitializer(mi);

    return vds;
}

---

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

License:Open Source License

private Statement getIDOCheckInStatement(AST ast) {
    ThisExpression thisExpression = ast.newThisExpression();
    MethodInvocation mi = ast.newMethodInvocation();
    mi.setExpression(thisExpression);/*from   w ww . j  a v  a2s.  co  m*/
    mi.setName(ast.newSimpleName("idoCheckInPooledEntity"));
    mi.arguments().add(ast.newSimpleName("entity"));

    return ast.newExpressionStatement(mi);
}

---

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

License:Open Source License

private Statement getObjectReturnStatement(AST ast, String methodName, String parameterName) {
    ThisExpression thisExpression = ast.newThisExpression();
    MethodInvocation mi = ast.newMethodInvocation();
    mi.setExpression(thisExpression);/*w  w  w . j  a v a 2 s .c  om*/
    mi.setName(ast.newSimpleName(methodName));
    mi.arguments().add(ast.newSimpleName(parameterName));

    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(mi);

    return returnStatement;
}

---

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

License:Apache License

/**
 * Generate constructor./*w w  w .j  a  v  a  2  s. com*/
 * 
 * @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.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  . j  av a  2  s.c  o  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 createInternalMethod(final TypeDeclaration parentTypeDeclaration, final MethodInformation m,
        final MethodDeclaration md) {
    final AST ast = md.getAST();

    final Block body = ast.newBlock();
    md.setBody(body);/*from  ww w .j a  v  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 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();// w  w  w.j  a  v a 2  s .  c  o  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
    }
}

---

• «
• 1
• 2
• 3
• 4
• »