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()}を利用すること。

            statements.add(createNullCheck(path));
            statements.add(createNullCheck(stream));


            SimpleName parser = f.newSimpleName("parser");
            statements.add(new TypeBuilder(f, context.resolve(CsvParser.class))
                .newObject(stream, path, new ExpressionBuilder(f, f.newThis())
                    .method(METHOD_CONFIG)
                    .toExpression())
                .toLocalVariableDeclaration(context.resolve(CsvParser.class), parser));


            statements.add(new TypeBuilder(f, f.newNamedType(f.newSimpleName(NAME_READER)))

View Full Code Here

            return new TypeBuilder(factory, t(AssertionError.class)).newObject().toThrowStatement();
        }


        private IfStatement createDiff(Expression diff) {
            return factory.newIfStatement(
                    new ExpressionBuilder(factory, diff)
                        .apply(InfixOperator.NOT_EQUALS, v(0))
                        .toExpression(),
                    new ExpressionBuilder(factory, diff)
                        .toReturnStatement(),
                    null);
        }

View Full Code Here

            statements.add(createNullCheck(path));
            statements.add(createNullCheck(stream));


            SimpleName emitter = f.newSimpleName("emitter");
            statements.add(new TypeBuilder(f, context.resolve(CsvEmitter.class))
                .newObject(stream, path, new ExpressionBuilder(f, f.newThis())
                    .method(METHOD_CONFIG)
                    .toExpression())
                .toLocalVariableDeclaration(context.resolve(CsvEmitter.class), emitter));


            statements.add(new TypeBuilder(f, f.newNamedType(f.newSimpleName(NAME_WRITER)))

View Full Code Here

                    null);
        }


        private IfStatement createDiff(Expression diff, boolean desc) {
            return factory.newIfStatement(
                    new ExpressionBuilder(factory, diff)
                        .apply(InfixOperator.NOT_EQUALS, v(0))
                        .toExpression(),
                    new ExpressionBuilder(factory, diff)
                        .apply(desc ? UnaryOperator.MINUS : UnaryOperator.PLUS)
                        .toReturnStatement(),
                    null);
        }

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 o2 = factory.newSimpleName("o2");


            List<Statement> statements = Lists.create();
            SimpleName segmentId1 = factory.newSimpleName("segmentId1");
            SimpleName segmentId2 = factory.newSimpleName("segmentId2");
            statements.add(new ExpressionBuilder(factory, o1)
                .method(SegmentedWritable.ID_GETTER)
                .toLocalVariableDeclaration(t(int.class), segmentId1));
            statements.add(new ExpressionBuilder(factory, o2)
                .method(SegmentedWritable.ID_GETTER)
                .toLocalVariableDeclaration(t(int.class), segmentId2));


            SimpleName diff = factory.newSimpleName("diff");
            statements.add(new ExpressionBuilder(factory, factory.newThis())
                .method(ShuffleEmiterUtil.COMPARE_INT,
                        new ExpressionBuilder(factory, factory.newThis())
                            .method(ShuffleEmiterUtil.PORT_TO_ELEMENT, segmentId1)
                            .toExpression(),
                        new ExpressionBuilder(factory, factory.newThis())
                            .method(ShuffleEmiterUtil.PORT_TO_ELEMENT, segmentId2)
                            .toExpression())
                .toLocalVariableDeclaration(t(int.class), diff));
            statements.add(createDiff(diff));


            List<Statement> cases = Lists.create();
            for (List<Segment> segments : ShuffleEmiterUtil.groupByElement(model)) {
                for (Segment segment : segments) {
                    cases.add(factory.newSwitchCaseLabel(v(segment.getPortId())));
                }
                Segment segment = segments.get(0);
                for (Term term : segment.getTerms()) {
                    if (term.getArrangement() != Arrangement.GROUPING) {
                        continue;
                    }
                    String name = ShuffleEmiterUtil.getPropertyName(segment, term);
                    Expression rhs = term.getSource().createValueDiff(
                            new ExpressionBuilder(factory, o1)
                                .field(name)
                                .toExpression(),
                            new ExpressionBuilder(factory, o2)
                                .field(name)
                                .toExpression());
                    cases.add(new ExpressionBuilder(factory, diff)
                        .assignFrom(rhs)
                        .toStatement());
                    cases.add(createDiff(diff));
                }
                cases.add(factory.newBreakStatement());
            }
            cases.add(factory.newSwitchDefaultLabel());
            cases.add(createAssertionError());


            statements.add(factory.newSwitchStatement(segmentId1, cases));


            statements.add(new ExpressionBuilder(factory, diff)
                .assignFrom(new ExpressionBuilder(factory, factory.newThis())
                    .method(ShuffleEmiterUtil.COMPARE_INT,
                            segmentId1,
                            segmentId2)
                    .toExpression())
                .toStatement());
            statements.add(createDiff(diff));


            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;
                    }
                    String name = ShuffleEmiterUtil.getPropertyName(segment, term);
                    Expression rhs = term.getSource().createValueDiff(
                            new ExpressionBuilder(factory, o1)
                                .field(name)
                                .toExpression(),
                            new ExpressionBuilder(factory, o2)
                                .field(name)
                                .toExpression());
                    cases.add(new ExpressionBuilder(factory, diff)
                        .assignFrom(rhs)
                        .toStatement());
                    cases.add(createDiff(diff, term.getArrangement() == Arrangement.DESCENDING));
                }
                cases.add(factory.newBreakStatement());
            }
            cases.add(factory.newSwitchDefaultLabel());
            cases.add(createAssertionError());


            statements.add(factory.newSwitchStatement(segmentId1, cases));
            statements.add(new ExpressionBuilder(factory, v(0))
                .toReturnStatement());


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

View Full Code Here

            members.add(createPrivateField(CsvParser.class, parser));
            List<ExpressionStatement> constructorStatements = Lists.create();
            constructorStatements.add(mapField(parser));
            if (hasFileName()) {
                members.add(createPrivateField(StringOption.class, f.newSimpleName(FIELD_PATH_NAME)));
                constructorStatements.add(new ExpressionBuilder(f, f.newSimpleName(FIELD_PATH_NAME))
                    .assignFrom(new TypeBuilder(f, context.resolve(StringOption.class))
                        .newObject(new ExpressionBuilder(f, parser)
                            .method("getPath")
                            .toExpression())
                        .toExpression())
                    .toStatement());
            }
            members.add(f.newConstructorDeclaration(
                    null,
                    new AttributeBuilder(f).toAttributes(),
                    f.newSimpleName(NAME_READER),
                    Arrays.asList(
                            f.newFormalParameterDeclaration(context.resolve(CsvParser.class), parser)),
                    constructorStatements));


            SimpleName object = f.newSimpleName("object");
            List<Statement> statements = Lists.create();
            statements.add(f.newIfStatement(
                    new ExpressionBuilder(f, parser)
                        .method("next")
                        .apply(InfixOperator.EQUALS, Models.toLiteral(f, false))
                        .toExpression(),
                    f.newBlock(new ExpressionBuilder(f, Models.toLiteral(f, false))
                        .toReturnStatement())));
            for (PropertyDeclaration property : model.getDeclaredProperties()) {
                switch (CsvFieldTrait.getKind(property, Kind.VALUE)) {
                case VALUE:
                    statements.add(new ExpressionBuilder(f, parser)
                        .method("fill", new ExpressionBuilder(f, object)
                            .method(context.getOptionGetterName(property))
                            .toExpression())
                        .toStatement());
                    break;
                case FILE_NAME:
                    statements.add(new ExpressionBuilder(f, object)
                        .method(context.getOptionSetterName(property), f.newSimpleName(FIELD_PATH_NAME))
                        .toStatement());
                    break;
                case LINE_NUMBER:
                    statements.add(new ExpressionBuilder(f, object)
                        .method(context.getValueSetterName(property), new ExpressionBuilder(f, parser)
                            .method("getCurrentLineNumber")
                            .toExpression())
                        .toStatement());
                    break;
                case RECORD_NUMBER:
                    statements.add(new ExpressionBuilder(f, object)
                        .method(context.getValueSetterName(property), new ExpressionBuilder(f, parser)
                            .method("getCurrentRecordNumber")
                            .toExpression())
                        .toStatement());
                    break;
                default:
                    // ignored
                    break;
                }
            }
            statements.add(new ExpressionBuilder(f, parser)
                .method("endRecord")
                .toStatement());
            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


            SimpleName object = f.newSimpleName("object");
            List<Statement> statements = Lists.create();
            for (PropertyDeclaration property : model.getDeclaredProperties()) {
                if (isValueField(property)) {
                    statements.add(new ExpressionBuilder(f, emitter)
                        .method("emit", new ExpressionBuilder(f, object)
                            .method(context.getOptionGetterName(property))
                            .toExpression())
                        .toStatement());
                }
            }
            statements.add(new ExpressionBuilder(f, emitter)
                .method("endRecord")
                .toStatement());


            members.add(f.newMethodDeclaration(
                    null,
                    new AttributeBuilder(f)
                        .annotation(context.resolve(Override.class))
                        .Public()
                        .toAttributes(),
                    Collections.<TypeParameterDeclaration>emptyList(),
                    context.resolve(void.class),
                    f.newSimpleName("write"),
                    Arrays.asList(f.newFormalParameterDeclaration(context.resolve(model.getSymbol()), object)),
                    0,
                    Arrays.asList(context.resolve(IOException.class)),
                    f.newBlock(statements)));


            members.add(f.newMethodDeclaration(
                    null,
                    new AttributeBuilder(f)
                        .annotation(context.resolve(Override.class))
                        .Public()
                        .toAttributes(),
                    Collections.<TypeParameterDeclaration>emptyList(),
                    context.resolve(void.class),
                    f.newSimpleName("flush"),
                    Collections.<FormalParameterDeclaration>emptyList(),
                    0,
                    Arrays.asList(context.resolve(IOException.class)),
                    f.newBlock(new ExpressionBuilder(f, emitter)
                        .method("flush")
                        .toStatement())));


            return f.newClassDeclaration(
                    null,

View Full Code Here

            }
            return false;
        }


        private ExpressionStatement mapField(SimpleName name) {
            return new ExpressionBuilder(f, f.newThis())
                .field(name)
                .assignFrom(name)
                .toStatement();
        }

View Full Code Here

                        .Public()
                        .toAttributes(),
                    type,
                    f.newSimpleName(name),
                    Collections.<FormalParameterDeclaration>emptyList(),
                    Arrays.asList(new ExpressionBuilder(f, value).toReturnStatement()));
        }

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.