Package com.asakusafw.compiler.operator

Examples of com.asakusafw.compiler.operator.ExecutableAnalyzer$TypeConstraint

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
    @Override
    public OperatorMethodDescriptor describe(Context context) {
        Precondition.checkMustNotBeNull(context, "context"); //$NON-NLS-1$

        ExecutableAnalyzer a = new ExecutableAnalyzer(context.environment, context.element);
        if (a.isAbstract()) {
            a.error("分岐演算子はabstractで宣言できません");
        }
        List<VariableElement> constants = Collections.emptyList();
        if (a.getReturnType().isEnum() == false) {
            a.error("分岐演算子は戻り値にpublicで宣言された列挙型を指定する必要があります");
        } else {
            constants = a.getReturnType().getEnumConstants();
            if (constants.isEmpty()) {
                a.error("分岐演算子の戻り値は定数が一つ以上宣言された列挙型である必要があります");
            }
        }
        if (a.getParameterType(0).isModel() == false) {
            a.error(0, "分岐演算子の最初の引数はモデルオブジェクト型である必要があります");
        }
        for (int i = 1, n = a.countParameters(); i < n; i++) {
            if (a.getParameterType(i).isBasic() == false) {
                a.error(i, "分岐演算子の2つ目以降の引数は文字列またはプリミティブ型である必要があります");
            }
        }
        if (a.hasError()) {
            return null;
        }

        Builder builder = new Builder(getTargetAnnotationType(), context);
        builder.addAttribute(a.getObservationCount());
        builder.setDocumentation(a.getExecutableDocument());
        builder.addInput(
                a.getParameterDocument(0),
                a.getParameterName(0),
                a.getParameterType(0).getType(),
                0);

        for (VariableElement var : constants) {
            builder.addOutput(
                    a.getDocument(var),
                    JavaName.of(var.getSimpleName().toString()).toMemberName(),
                    a.getParameterType(0).getType(),
                    a.getParameterName(0),
                    null);
        }
        for (int i = 1, n = a.countParameters(); i < n; i++) {
            builder.addParameter(
                    a.getParameterDocument(i),
                    a.getParameterName(i),
                    a.getParameterType(i).getType(),
                    i);
        }
        return builder.toDescriptor();
    }
View Full Code Here
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
    @Override
    public OperatorMethodDescriptor describe(Context context) {
        Precondition.checkMustNotBeNull(context, "context"); //$NON-NLS-1$

        ExecutableAnalyzer a = new ExecutableAnalyzer(context.environment, context.element);
        if (a.isAbstract()) {
            a.error("変換演算子はabstractで宣言できません");
        }
        if (a.getReturnType().isConcreteModel() == false) {
            a.error("変換演算子は戻り値にモデルオブジェクト型を指定する必要があります");
        }
        if (a.getParameterType(0).isModel() == false) {
            a.error(0, "変換演算子の最初の引数はモデルオブジェクト型である必要があります");
        }
        for (int i = 1, n = a.countParameters(); i < n; i++) {
            if (a.getParameterType(i).isBasic() == false) {
                a.error(i, "変換演算子の2つ目以降の引数は文字列またはプリミティブ型である必要があります");
            }
        }
        Convert annotation = context.element.getAnnotation(Convert.class);
        if (annotation == null) {
            a.error("注釈の解釈に失敗しました");
            return null;
        }
        OperatorProcessorUtil.checkPortName(a, new String[] {
                annotation.originalPort(),
                annotation.convertedPort(),
        });
        if (a.hasError()) {
            return null;
        }

        Builder builder = new Builder(getTargetAnnotationType(), context);
        builder.addAttribute(a.getObservationCount());
        builder.setDocumentation(a.getExecutableDocument());
        builder.addInput(
                a.getParameterDocument(0),
                a.getParameterName(0),
                a.getParameterType(0).getType(),
                0);
        builder.addOutput(
                "入力された内容",
                annotation.originalPort(),
                a.getParameterType(0).getType(),
                a.getParameterName(0),
                0);
        builder.addOutput(
                a.getReturnDocument(),
                annotation.convertedPort(),
                a.getReturnType().getType(),
                null,
                null);
        for (int i = 1, n = a.countParameters(); i < n; i++) {
            builder.addParameter(
                    a.getParameterDocument(i),
                    a.getParameterName(i),
                    a.getParameterType(i).getType(),
                    i);
        }
        return builder.toDescriptor();
    }
View Full Code Here
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
public class SplitOperatorProcessor extends AbstractOperatorProcessor {

    @Override
    public OperatorMethodDescriptor describe(Context context) {
        Precondition.checkMustNotBeNull(context, "context"); //$NON-NLS-1$
        ExecutableAnalyzer a = new ExecutableAnalyzer(context.environment, context.element);
        if (a.isGeneric()) {
            a.error("分割演算子はジェネリックメソッドで宣言できません");
        }
        if (a.isAbstract() == false) {
            a.error("分割演算子はabstractを指定する必要があります");
        }
        if (a.getReturnType().isVoid() == false) {
            a.error("分割演算子は戻り値にvoidを指定する必要があります");
        }
        if (a.getParameterType(0).isConcreteModel() == false) {
            a.error(0, "分割演算子の最初の引数はモデルオブジェクト型である必要があります");
        }
        for (int i = 1; i <= 2; i++) {
            if (a.getParameterType(i).isResult() == false) {
                a.error(i, "分割演算子の{0}つ目の引数は結果型である必要があります", i + 1);
            } else if (a.getParameterType(i).getTypeArgument().isModel() == false) {
                a.error(i, "分割演算子の{0}つ目の引数は結果のモデル型である必要があります", i + 1);
            }
        }
        for (int i = 3, n = a.countParameters(); i < n; i++) {
            a.error(i, "分割演算子にはユーザー引数を利用できません");
        }
        if (a.hasError()) {
            return null;
        }

        TypeConstraint joined = a.getParameterType(0);
        TypeConstraint from = a.getParameterType(1).getTypeArgument();
        TypeConstraint join = a.getParameterType(2).getTypeArgument();
        if (joined.isJoinedModel(from.getType(), join.getType()) == false) {
            a.error(0, "分割演算子の最初の引数は結果の2つの型を結合した型である必要があります");
            return null;
        }

        Builder builder = new Builder(getTargetAnnotationType(), context);
        builder.addAttribute(a.getObservationCount());
        builder.setDocumentation(a.getExecutableDocument());
        builder.addInput(
                a.getParameterDocument(0),
                a.getParameterName(0),
                a.getParameterType(0).getType(),
                0);
        builder.addOutput(
                a.getParameterDocument(1),
                a.getParameterName(1),
                a.getParameterType(1).getTypeArgument().getType(),
                null,
                1);
        builder.addOutput(
                a.getParameterDocument(2),
                a.getParameterName(2),
                a.getParameterType(2).getTypeArgument().getType(),
                null,
                2);

        return builder.toDescriptor();
    }
View Full Code Here
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
    @Override
    public OperatorMethodDescriptor describe(Context context) {
        Precondition.checkMustNotBeNull(context, "context"); //$NON-NLS-1$

        ExecutableAnalyzer a = new ExecutableAnalyzer(context.environment, context.element);
        if (a.isAbstract() == false) {
            a.error("重複検出演算子はabstractで宣言する必要があります");
        }
        if (a.getReturnType().isVoid() == false) {
            a.error("重複検出演算子は戻り値にvoidを指定する必要があります");
        }
        if (a.getParameterType(0).isModel() == false) {
            a.error(0, "重複検出演算子の最初の引数はモデルオブジェクト型である必要があります");
        }
        for (int i = 1, n = a.countParameters(); i < n; i++) {
            a.error(i, "重複検出演算子にはユーザー引数を利用できません");
        }
        if (a.hasError()) {
            return null;
        }

        ShuffleKey key = a.getParameterKey(0);
        if (key == null) {
            a.error("重複検出演算子の引数には@Key注釈によってグループ化項目を指定する必要があります");
            return null;
        }
        if (a.hasError()) {
            return null;
        }

        Builder builder = new Builder(getTargetAnnotationType(), context);
        builder.addAttribute(FlowBoundary.SHUFFLE);
        builder.addAttribute(a.getObservationCount());
        builder.setDocumentation(a.getExecutableDocument());
        builder.addInput(
                a.getParameterDocument(0),
                a.getParameterName(0),
                a.getParameterType(0).getType(),
                0,
                key);
        builder.addOutput(
                "項目の内容が一意であるデータが流れる出力",
                "unique",
                a.getParameterType(0).getType(),
                a.getParameterName(0),
                null);
        builder.addOutput(
                "項目の内容が一意でないデータが流れる出力",
                "duplicated",
                a.getParameterType(0).getType(),
                a.getParameterName(0),
                null);
        return builder.toDescriptor();
    }
View Full Code Here
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    @Override
    public OperatorMethodDescriptor describe(Context context) {
        Precondition.checkMustNotBeNull(context, "context"); //$NON-NLS-1$

        ExecutableAnalyzer a = new ExecutableAnalyzer(context.environment, context.element);
        if (a.isAbstract()) {
            a.error("グループ結合演算子はabstractで宣言できません");
        }
        if (a.getReturnType().isVoid() == false) {
            a.error("グループ結合演算子は戻り値にvoidを指定する必要があります");
        }
        int startResults = 0;
        for (int i = 0, n = a.countParameters(); i < n; i++) {
            TypeConstraint type = a.getParameterType(i);
            if (type.isResult()) {
                break;
            }
            if (type.isList() == false) {
                a.error(i, "グループ結合演算子の先頭の引数はリスト型(java.util.List)である必要があります");
            } else if (type.getTypeArgument().isModel() == false) {
                a.error(i, "グループ結合演算子の先頭の引数はリストのモデルオブジェクト型である必要があります");
            }
            startResults++;
        }
        if (startResults == 0) { // リスト型がない
            a.error("グループ結合演算子の引数には一つ以上のリスト型(java.util.List)を指定する必要があります");
        }

        int startParameters = startResults;
        for (int i = startResults, n = a.countParameters(); i < n; i++) {
            TypeConstraint param = a.getParameterType(i);
            if (param.isResult() == false) {
                break;
            } else if (param.getTypeArgument().isModel() == false) {
                a.error(i, "グループ結合演算子の結果は結果のモデルオブジェクト型である必要があります");
            } else {
                startParameters++;
            }
        }
        if (startParameters == startResults) { // 結果型がない
            a.error("グループ結合演算子の引数には一つ以上の結果(Result)型を指定する必要があります");
        }
        for (int i = startParameters, n = a.countParameters(); i < n; i++) {
            TypeConstraint param = a.getParameterType(i);
            if (param.isResult()) {
                a.error(i, "ユーザー引数の後には結果型を含められません");
            } else if (param.isBasic() == false) {
                a.error(i, "ユーザー引数は文字列またはプリミティブ型である必要があります");
            }
        }
        if (a.hasError()) {
            return null;
        }

        List<ShuffleKey> keys = Lists.create();
        for (int i = 0; i < startResults; i++) {
            ShuffleKey key = a.getParameterKey(i);
            if (key == null) {
                a.error(i, "グループ結合演算子の引数には@Key注釈によってグループ化項目を指定する必要があります");
            } else {
                keys.add(key);
            }
        }
        if (keys.isEmpty() == false) {
            ShuffleKey first = keys.get(0);
            for (int i = 1, n = keys.size(); i < n; i++) {
                if (first.getGroupProperties().size() != keys.get(i).getGroupProperties().size()) {
                    a.error(0, "グループ結合演算子の@Key注釈ではグループ化項目の個数を全て一致させる必要があります");
                }
            }
        }
        if (a.hasError()) {
            return null;
        }
        CoGroup annotation = context.element.getAnnotation(CoGroup.class);
        if (annotation == null) {
            a.error("注釈の解釈に失敗しました");
            return null;
        }

        Builder builder = new Builder(getTargetAnnotationType(), context);
        builder.addAttribute(FlowBoundary.SHUFFLE);
        builder.addAttribute(a.getObservationCount());
        builder.addAttribute(annotation.inputBuffer());
        builder.setDocumentation(a.getExecutableDocument());
        for (int i = 0; i < startResults; i++) {
            builder.addInput(
                    a.getParameterDocument(i),
                    a.getParameterName(i),
                    a.getParameterType(i).getTypeArgument().getType(),
                    i,
                    keys.get(i));
        }
        for (int i = startResults; i < startParameters; i++) {
            TypeConstraint outputType = a.getParameterType(i).getTypeArgument();
            TypeMirror outputTypeMirror = outputType.getType();
            String found = builder.findInput(outputTypeMirror);
            if (found == null && outputType.isProjectiveModel()) {
                a.error("出力型{0}に対する入力が見つかりません", outputTypeMirror);
            }
            builder.addOutput(
                    a.getParameterDocument(i),
                    a.getParameterName(i),
                    outputTypeMirror,
                    found,
                    i);
        }
        for (int i = startParameters, n = a.countParameters(); i < n; i++) {
            builder.addParameter(
                    a.getParameterDocument(i),
                    a.getParameterName(i),
                    a.getParameterType(i).getType(),
                    i);
        }
        return builder.toDescriptor();
    }
View Full Code Here
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
    @Override
    public OperatorMethodDescriptor describe(Context context) {
        Precondition.checkMustNotBeNull(context, "context"); //$NON-NLS-1$

        ExecutableAnalyzer a = new ExecutableAnalyzer(context.environment, context.element);
        if (a.isGeneric()) {
            a.error("単純集計演算子はジェネリックメソッドで宣言できません");
        }
        if (a.isAbstract() == false) {
            a.error("単純集計演算子はabstractで宣言する必要があります");
        }
        TypeConstraint summarized = a.getReturnType();
        if (summarized.isConcreteModel() == false) {
            a.error("単純集計演算子は戻り値にモデルオブジェクト型を指定する必要があります");
        }
        TypeConstraint summarizee = a.getParameterType(0);
        if (summarizee.isModel() == false) {
            a.error(0, "単純集計演算子の最初の引数はモデルオブジェクト型である必要があります");
        }
        for (int i = 1, n = a.countParameters(); i < n; i++) {
            a.error(i, "単純集計演算子にはユーザー引数を利用できません");
        }
        if (a.hasError()) {
            return null;
        }
        if (summarized.isSummarizedModel(summarizee.getType()) == false) {
            a.error("単純集計演算子の戻り値型は最初の引数の集計結果を表す型である必要があります");
            return null;
        }

        ShuffleKey key = summarized.getSummarizeKey();
        Summarize annotation = context.element.getAnnotation(Summarize.class);
        if (annotation == null) {
            a.error("注釈の解釈に失敗しました");
            return null;
        }
        OperatorProcessorUtil.checkPortName(a, new String[] {
                annotation.summarizedPort(),
        });
        if (a.hasError()) {
            return null;
        }

        Builder builder = new Builder(getTargetAnnotationType(), context);
        builder.addAttribute(FlowBoundary.SHUFFLE);
        builder.addAttribute(a.getObservationCount());
        builder.addAttribute(annotation.partialAggregation());
        builder.setDocumentation(a.getExecutableDocument());
        builder.addInput(
                a.getParameterDocument(0),
                a.getParameterName(0),
                a.getParameterType(0).getType(),
                0,
                key);
        builder.addOutput(
                a.getReturnDocument(),
                annotation.summarizedPort(),
                a.getReturnType().getType(),
                null,
                null);
        return builder.toDescriptor();
    }
View Full Code Here
TOP

Related Classes of com.asakusafw.compiler.operator.ExecutableAnalyzer$TypeConstraint

  • com.asakusafw.compiler.operator.flow.FlowPartClassCollector
  • com.asakusafw.compiler.operator.processor.BranchOperatorProcessor
  • com.asakusafw.compiler.operator.processor.CoGroupOperatorProcessor
  • com.asakusafw.compiler.operator.processor.ConvertOperatorProcessor
  • com.asakusafw.compiler.operator.processor.ExtractOperatorProcessor
  • com.asakusafw.compiler.operator.processor.FoldOperatorProcessor
  • com.asakusafw.compiler.operator.processor.GroupSortOperatorProcessor
  • com.asakusafw.compiler.operator.processor.LoggingOperatorProcessor
  • com.asakusafw.compiler.operator.processor.MasterBranchOperatorProcessor
  • com.asakusafw.compiler.operator.processor.MasterCheckOperatorProcessor
    • Copyright © 2018 www.massapicom. All rights reserved.
    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.