Examples of com.asakusafw.utils.java.model.util.ExpressionBuilder

Package com.asakusafw.utils.java.model.util

Examples of com.asakusafw.utils.java.model.util.ExpressionBuilder

com.asakusafw.utils.java.model.util.ExpressionBuilder
式を構築するビルダー。
このクラスのオブジェクトは、自身を破壊的に変更して式を構築する。特定の状態のビルダーを再利用する場合、 {@link #copy()}を利用すること。

            SimpleName key = factory.newSimpleName("key");
            List<Statement> statements = Lists.create();
            SimpleName portId = factory.newSimpleName("portId");
            SimpleName result = factory.newSimpleName("result");


            statements.add(new ExpressionBuilder(factory, key)
                .method(SegmentedWritable.ID_GETTER)
                .toLocalVariableDeclaration(t(int.class), portId));
            statements.add(new ExpressionBuilder(factory, factory.newThis())
                .method(ShuffleEmiterUtil.PORT_TO_ELEMENT, portId)
                .toLocalVariableDeclaration(t(int.class), result));


            List<Statement> cases = Lists.create();
            for (Segment segment : model.getSegments()) {
                cases.add(factory.newSwitchCaseLabel(v(segment.getPortId())));
                for (Term term : segment.getTerms()) {
                    if (term.getArrangement() != Arrangement.GROUPING) {
                        continue;
                    }
                    Expression hash = term.getSource().createHashCode(
                            new ExpressionBuilder(factory, key)
                                .field(ShuffleEmiterUtil.getPropertyName(segment, term))
                                .toExpression());
                    cases.add(new ExpressionBuilder(factory, result)
                        .assignFrom(
                                new ExpressionBuilder(factory, result)
                                    .apply(InfixOperator.TIMES, v(31))
                                    .apply(InfixOperator.PLUS, hash)
                                    .toExpression())
                        .toStatement());
                }
                cases.add(factory.newBreakStatement());
            }
            cases.add(factory.newSwitchDefaultLabel());
            cases.add(new TypeBuilder(factory, t(AssertionError.class))
                .newObject(portId)
                .toThrowStatement());


            statements.add(factory.newSwitchStatement(portId, cases));
            statements.add(new ExpressionBuilder(factory, result)
                .toReturnStatement());


            return factory.newMethodDeclaration(
                    null,
                    new AttributeBuilder(factory)

View Full Code Here

                factory.newSimpleName("as"),
                Collections.singletonList(factory.newFormalParameterDeclaration(
                        util.t(String.class),
                        newName)),
                Arrays.asList(new Statement[] {
                        new ExpressionBuilder(factory, factory.newThis())
                            .field(RESOLVER_FIELD_NAME)
                            .method("setName", newName)
                            .toStatement(),
                        new ExpressionBuilder(factory, factory.newThis())
                            .toReturnStatement(),
                }));
    }

View Full Code Here

        statements.add(new TypeBuilder(factory, util.t(OperatorDescription.Builder.class))
            .newObject(factory.newClassLiteral(util.t(descriptor.getAnnotationType())))
            .toLocalVariableDeclaration(
                    util.t(OperatorDescription.Builder.class),
                    builderName));
        statements.add(new ExpressionBuilder(factory, builderName)
            .method("declare",
                    factory.newClassLiteral(util.t(operatorClass.getElement())),
                    factory.newClassLiteral(factory.newNamedType(
                            util.getImplementorName(operatorClass.getElement()))),
                    util.v(descriptor.getName()))
            .toStatement());
        for (VariableElement parameter : context.element.getParameters()) {
            statements.add(new ExpressionBuilder(factory, builderName)
                .method("declareParameter",
                        new TypeBuilder(factory, util.t(environment.getErasure(parameter.asType())))
                            .dotClass()
                            .toExpression())
                .toStatement());
        }


        for (OperatorPortDeclaration var : descriptor.getInputPorts()) {
            ShuffleKey key = var.getShuffleKey();
            List<Expression> arguments = Lists.create();
            arguments.add(util.v(var.getName()));
            arguments.add(factory.newSimpleName(var.getName()));
            if (key != null) {
                arguments.add(toSource(key));
            }
            statements.add(new ExpressionBuilder(factory, builderName)
                .method("addInput", arguments)
                .toStatement());
        }
        for (OperatorPortDeclaration var : descriptor.getOutputPorts()) {
            Expression type = toExpression(var);
            statements.add(new ExpressionBuilder(factory, builderName)
                .method("addOutput", util.v(var.getName()), type)
                .toStatement());
        }
        for (OperatorPortDeclaration var : descriptor.getParameters()) {
            Expression type = toExpression(var);
            statements.add(new ExpressionBuilder(factory, builderName)
                .method("addParameter",
                        util.v(var.getName()),
                        type,
                        factory.newSimpleName(var.getName()))
                .toStatement());
        }
        for (Expression attr : descriptor.getAttributes()) {
            statements.add(new ExpressionBuilder(factory, builderName)
                .method("addAttribute", attr)
                .toStatement());
        }
        Expression resolver = new ExpressionBuilder(factory, factory.newThis())
            .field(RESOLVER_FIELD_NAME)
            .toExpression();
        statements.add(new ExpressionBuilder(factory, resolver)
            .assignFrom(new ExpressionBuilder(factory, builderName)
                .method("toResolver")
                .toExpression())
            .toStatement());
        for (OperatorPortDeclaration var : descriptor.getInputPorts()) {
            statements.add(new ExpressionBuilder(factory, resolver)
                .method("resolveInput",
                        util.v(var.getName()),
                        factory.newSimpleName(var.getName()))
                .toStatement());
        }
        for (OperatorPortDeclaration var : descriptor.getOutputPorts()) {
            statements.add(new ExpressionBuilder(factory, factory.newThis())
                .field(var.getName())
                .assignFrom(new ExpressionBuilder(factory, resolver)
                    .method("resolveOutput", util.v(var.getName()))
                    .toExpression())
                .toStatement());
        }
        return statements;

View Full Code Here

            List<PropertyDeclaration> properties = getProperties();
            for (int i = 0, n = properties.size(); i < n; i++) {
                PropertyDeclaration property = properties.get(i);
                JdbcColumnTrait trait = property.getTrait(JdbcColumnTrait.class);
                assert trait != null;
                statements.add(new ExpressionBuilder(f, map)
                    .method("put", Models.toLiteral(f, trait.getName()), Models.toLiteral(f, i))
                    .toStatement());
            }
            statements.add(new ExpressionBuilder(f, f.newSimpleName(NAME_PROPERTY_POSITIONS))
                .assignFrom(map)
                .toStatement());
            results.add(f.newInitializerDeclaration(
                    null,
                    new AttributeBuilder(f)

View Full Code Here

        private MethodDeclaration createIsSupported() {
            SimpleName columnNames = f.newSimpleName("columnNames");
            List<Statement> statements = Lists.create();
            statements.add(createNullCheck(columnNames));
            statements.add(f.newIfStatement(
                    new ExpressionBuilder(f, columnNames)
                        .method("isEmpty")
                        .toExpression(),
                    f.newBlock(f.newReturnStatement(Models.toLiteral(f, false)))));
            statements.add(f.newTryStatement(
                    f.newBlock(
                            new ExpressionBuilder(f, f.newThis())
                                .method(NAME_CREATE_VECTOR, columnNames)
                                .toStatement(),
                            new ExpressionBuilder(f, Models.toLiteral(f, true))
                                .toReturnStatement()),
                    Arrays.asList(f.newCatchClause(
                            f.newFormalParameterDeclaration(
                                    context.resolve(IllegalArgumentException.class),
                                    f.newSimpleName("e")),
                            f.newBlock(new ExpressionBuilder(f, Models.toLiteral(f, false))
                                .toReturnStatement()))),
                    null));
            MethodDeclaration decl = f.newMethodDeclaration(
                    null,
                    new AttributeBuilder(f)

View Full Code Here

            SimpleName columnNames = f.newSimpleName("columnNames");
            List<Statement> statements = Lists.create();
            statements.add(createNullCheck(resultSet));
            statements.add(createNullCheck(columnNames));
            SimpleName vector = f.newSimpleName("vector");
            statements.add(new ExpressionBuilder(f, f.newThis())
                .method(NAME_CREATE_VECTOR, columnNames)
                .toLocalVariableDeclaration(context.resolve(int[].class), vector));
            statements.add(new TypeBuilder(f, f.newNamedType(f.newSimpleName(NAME_RESULT_SET_SUPPORT)))
                .newObject(resultSet, vector)
                .toReturnStatement());

View Full Code Here

            SimpleName columnNames = f.newSimpleName("columnNames");
            List<Statement> statements = Lists.create();
            statements.add(createNullCheck(preparedStatement));
            statements.add(createNullCheck(columnNames));
            SimpleName vector = f.newSimpleName("vector");
            statements.add(new ExpressionBuilder(f, f.newThis())
                .method(NAME_CREATE_VECTOR, columnNames)
                .toLocalVariableDeclaration(context.resolve(int[].class), vector));
            statements.add(new TypeBuilder(f, f.newNamedType(f.newSimpleName(NAME_PREPARED_STATEMENT_SUPPORT)))
                .newObject(preparedStatement, vector)
                .toReturnStatement());

View Full Code Here

        }


        private Statement createNullCheck(SimpleName parameter) {
            assert parameter != null;
            return f.newIfStatement(
                    new ExpressionBuilder(f, parameter)
                        .apply(InfixOperator.EQUALS, Models.toNullLiteral(f))
                        .toExpression(),
                    f.newBlock(new TypeBuilder(f, context.resolve(IllegalArgumentException.class))
                        .newObject(Models.toLiteral(f, MessageFormat.format(
                                "{0} must not be null",

View Full Code Here

            SimpleName columnNames = f.newSimpleName("columnNames");
            SimpleName vector = f.newSimpleName("vector");
            List<Statement> statements = Lists.create();


            statements.add(new TypeBuilder(f, context.resolve(int[].class))
                .newArray(new ExpressionBuilder(f, f.newSimpleName(NAME_PROPERTY_POSITIONS))
                    .method("size")
                    .toExpression())
                .toLocalVariableDeclaration(context.resolve(int[].class), vector));


            SimpleName index = f.newSimpleName("i");
            SimpleName column = f.newSimpleName("column");
            SimpleName position = f.newSimpleName("position");
            statements.add(f.newForStatement(
                    f.newLocalVariableDeclaration(
                            new AttributeBuilder(f).toAttributes(),
                            context.resolve(int.class),
                            Arrays.asList(
                                    f.newVariableDeclarator(
                                            index,
                                            Models.toLiteral(f, 0)),
                                    f.newVariableDeclarator(
                                            f.newSimpleName("n"),
                                            new ExpressionBuilder(f, columnNames)
                                                .method("size")
                                                .toExpression()))),
                    new ExpressionBuilder(f, index)
                        .apply(InfixOperator.LESS, f.newSimpleName("n"))
                        .toExpression(),
                    f.newStatementExpressionList(new ExpressionBuilder(f, index)
                        .apply(PostfixOperator.INCREMENT)
                        .toExpression()),
                    f.newBlock(new Statement[] {
                            new ExpressionBuilder(f, columnNames)
                                .method("get", index)
                                .toLocalVariableDeclaration(context.resolve(String.class), column),
                            new ExpressionBuilder(f, f.newSimpleName(NAME_PROPERTY_POSITIONS))
                                .method("get", column)
                                .toLocalVariableDeclaration(context.resolve(Integer.class), position),
                            f.newIfStatement(
                                    new ExpressionBuilder(f, position)
                                        .apply(InfixOperator.EQUALS, Models.toNullLiteral(f))
                                        .apply(InfixOperator.CONDITIONAL_OR, new ExpressionBuilder(f, vector)
                                            .array(position)
                                            .apply(InfixOperator.NOT_EQUALS, Models.toLiteral(f, 0))
                                            .toExpression())
                                        .toExpression(),
                                    f.newBlock(new TypeBuilder(f, context.resolve(IllegalArgumentException.class))
                                        .newObject(column)
                                        .toThrowStatement())),
                            new ExpressionBuilder(f, vector)
                                .array(position)
                                .assignFrom(new ExpressionBuilder(f, index)
                                    .apply(InfixOperator.PLUS, Models.toLiteral(f, 1))
                                    .toExpression())
                            .toStatement()
                    })));
            statements.add(new ExpressionBuilder(f, vector).toReturnStatement());
            return f.newMethodDeclaration(
                    null,
                    new AttributeBuilder(f)
                        .Private()
                        .toAttributes(),

View Full Code Here

                    Arrays.asList(mapField(resultSet), mapField(properties))));


            SimpleName object = f.newSimpleName("object");
            List<Statement> statements = Lists.create();
            statements.add(f.newIfStatement(
                    new ExpressionBuilder(f, resultSet)
                        .method("next")
                        .apply(InfixOperator.EQUALS, Models.toLiteral(f, false))
                        .toExpression(),
                    f.newBlock(new ExpressionBuilder(f, Models.toLiteral(f, false))
                        .toReturnStatement())));
            List<PropertyDeclaration> declared = getProperties();
            for (int i = 0, n = declared.size(); i < n; i++) {
                statements.add(createResultSetSupportStatement(
                        object,
                        resultSet,
                        f.newArrayAccessExpression(properties, Models.toLiteral(f, i)),
                        declared.get(i)));
            }
            statements.add(new ExpressionBuilder(f, Models.toLiteral(f, true))
                .toReturnStatement());
            members.add(f.newMethodDeclaration(
                    null,
                    new AttributeBuilder(f)
                        .annotation(context.resolve(Override.class))

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.asakusafw.utils.java.model.util.ExpressionBuilder

com.asakusafw.compiler.directio.emitter.NamingClassEmitter$Engine

com.asakusafw.compiler.directio.emitter.OrderingClassEmitter$Engine

com.asakusafw.compiler.directio.emitter.StageEmitter$Engine

com.asakusafw.compiler.flow.FlowElementProcessor$ListBufferMirror

com.asakusafw.compiler.flow.FlowElementProcessor$ResultMirror

com.asakusafw.compiler.flow.jobflow.StageClientEmitter$Engine

com.asakusafw.compiler.flow.join.JoinResourceEmitter

com.asakusafw.compiler.flow.join.processor.SideDataBranchFlowProcessor

com.asakusafw.compiler.flow.join.processor.SideDataJoinUpdateFlowProcessor

com.asakusafw.compiler.flow.join.processor.SideDataKindFlowAnalyzer

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.