diff --git a/models/memo-application-sample.json b/models/memo-application-sample.json new file mode 100644 index 0000000..a074d1c --- /dev/null +++ b/models/memo-application-sample.json @@ -0,0 +1,87 @@ +{ + "screen": { + "メモ表示画面": { + "label": { + "wType": "label", + "wText": "メモ:", + "wX": 50, + "wY": 50, + "wWidth": 50, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "black" + }, + "memo": { + "wType": "label", + "wText": "", + "wX": 120, + "wY": 50, + "wWidth": 300, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "black" + }, + "editButton": { + "wType": "button", + "wText": "編集", + "wX": 330, + "wY": 170, + "wWidth": 60, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "blue" + } + }, + "メモ編集画面": { + "label": { + "wType": "label", + "wText": "メモ:", + "wX": 50, + "wY": 50, + "wWidth": 50, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "black" + }, + "memoInput": { + "wType": "textInput", + "wText": "", + "wX": 120, + "wY": 50, + "wWidth": 300, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "black" + }, + "okButton": { + "wType": "button", + "wText": "OK", + "wX": 330, + "wY": 170, + "wWidth": 60, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "blue" + }, + "canselButton": { + "wType": "button", + "wText": "キャンセル", + "wX": 330, + "wY": 170, + "wWidth": 120, + "wHeight": 30, + "wEnabled": true, + "wVisible": true, + "wColor": "black" + } + } + }, + "table": { + } +} \ No newline at end of file diff --git a/models/screen-table-sample.json b/models/screen-table-sample.json new file mode 100644 index 0000000..ff58339 --- /dev/null +++ b/models/screen-table-sample.json @@ -0,0 +1,54 @@ +{ + "screen": { + "一覧画面": { + "editButton": { + "wType": "button", + "wText": "編集", + "wX": 100, + "wY": 100, + "wWidth": 50, + "wHeight": 20, + "wEnabled": true, + "wVisible": true, + "wColor": "blue" + }, + "customerTable":{ + "wType": "table", + "wX": 100, + "wY": 200, + "wWidth": 1200, + "wHeight": 800, + "wEnabled": true, + "wVisible": true + } + }, + "編集画面": { + "nameInput": { + "wType": "textInput", + "wText": "", + "wX": 100, + "wY": 100, + "wWidth": 100, + "wHeight": 20, + "wVisible": true + }, + "updateButton": { + "wType": "button", + "wText": "更新", + "wX": 300, + "wY": 300, + "wWidth": 50, + "wHeight": 20, + "wEnabled": true, + "wVisible": true, + "wColor": "blue" + } + } + }, + "table":{ + "顧客": { + "keyName": "顧客ID", + "columnName": ["顧客名", "メールアドレス", "会社ID"] + } + } +} \ No newline at end of file diff --git a/models/screen-wighet-sample.json b/models/screen-wighet-sample.json new file mode 100644 index 0000000..6df8345 --- /dev/null +++ b/models/screen-wighet-sample.json @@ -0,0 +1,42 @@ +{ + "一覧画面": { + "editButton": { + "wType": "button", + "wText": "編集", + "wX": 100, + "wY": 100, + "wWidth": 50, + "wHeight": 20, + "wEnabled": true, + "wColor": "blue" + }, + "customerTable":{ + "wType": "table", + "wX": 100, + "wY": 200, + "wWidth": 1200, + "wHeight": 800, + "wEnabled": true + } + }, + "編集画面": { + "nameInput": { + "wType": "textInput", + "wText": "", + "wX": 100, + "wY": 100, + "wWidth": 100, + "wHeight": 20 + }, + "updateButton": { + "wType": "button", + "wText": "更新", + "wX": 300, + "wY": 300, + "wWidth": 50, + "wHeight": 20, + "wEnabled": true, + "wColor": "blue" + } + } +} \ No newline at end of file diff --git a/src/main/java/org/ntlab/rdlcanvas/Main.java b/src/main/java/org/ntlab/rdlcanvas/Main.java index 0330b5b..3834ddd 100644 --- a/src/main/java/org/ntlab/rdlcanvas/Main.java +++ b/src/main/java/org/ntlab/rdlcanvas/Main.java @@ -1,22 +1,25 @@ package org.ntlab.rdlcanvas; -import org.ntlab.rdlcanvas.parser.JsonValue; -import org.ntlab.rdlcanvas.parser.Parser; -import org.ntlab.rdlcanvas.parser.StringValue; -import org.ntlab.rdlcanvas.parser.Value; -import java.util.Map; +import org.ntlab.rdlcanvas.generaterdl.RDLGenerator; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; + public class Main { public static void main(String[] args) { - Parser parser = new Parser(); - Value value = parser.getValue(); - System.out.println(value.toString()); + File file = new File("models/screen-table-sample.json"); -// Map map = ((JsonValue)value).getKeyToValue(); -// for (StringValue key : map.keySet()){ -// String keyName = key.getStringValue(); -// System.out.println(keyName); -// } + try { + BufferedReader reader = new BufferedReader(new FileReader(file)); + RDLGenerator rdlGenerator = new RDLGenerator(reader); + System.out.println(rdlGenerator.getSpec().toString()); + + } catch (FileNotFoundException e) { + + } } } diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecific.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecific.java new file mode 100644 index 0000000..59b80b6 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecific.java @@ -0,0 +1,56 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.RDLSpecDependencyTerm; +import org.ntlab.rdlcanvas.models.RDLSpecEvaluatableTerm; + +import java.util.List; + +public class AppSpecific extends GeneratorBase { + + + public AppSpecific() { + + } + + // [[metaId : wId -> wIdName] : scId -> scIdName] ex: [[wText : wId -> "editButton"] : scId -> "一覧画面"]] + public RDLSpecDependencyTerm createWidgetMetaIdDependencyTerm(String metaIdName, String wIdName, String scIdName, boolean Primed) { + RDLSpecDependencyTerm widgetDependencyTerm; + if (Primed) { + widgetDependencyTerm = createNestedDependencyTermFromTerm(createDependencyTerm(metaIdName, "wId", true, wIdName), "scId", true, scIdName); + } else { + widgetDependencyTerm = createNestedDependencyTermFromTerm(createDependencyTerm(metaIdName, "wId", false, wIdName), "scId", false, scIdName); + } + + return widgetDependencyTerm; + } + + //ex: [[wState : wId -> "editButton"] : scId -> "一覧画面"] + public RDLSpecDependencyTerm createStateDependencyTerm(String wIdName, String scId) { + RDLSpecDependencyTerm stateDependencyTerm; + + stateDependencyTerm = createNestedDependencyTermFromTerm(createDependencyTerm("wState", false, "wId", true, wIdName), "scId", true, scId); + + return stateDependencyTerm; + } + + // [[columnValue : columnNo -> columnNum, key -> curKey] : tableId -> tableIdName] ex: [[columnValue : columnNo -> "0", key -> curKey] : tableId -> "顧客"] + public RDLSpecDependencyTerm createColumnValueDependencyTerm(String columnNum, String tableIdName) { + RDLSpecDependencyTerm tableOutsideDependencyTerm; + RDLSpecDependencyTerm tableInsideDependencyTerm = createDependencyTerm("columnValue", false, "columnNo", false, columnNum, "key", false, "curKey"); + tableOutsideDependencyTerm = createNestedDependencyTermFromTerm(tableInsideDependencyTerm, "tableId", false, tableIdName); + + return tableOutsideDependencyTerm; + } + + // [depending : depended01 -> constantArgument01, depended02 -> constantArgument02] + public RDLSpecDependencyTerm createDependencyTerm(String depending, boolean isDependingPrimed, String depended01, boolean isDependedPrimed01, String constantArgument, String depended02, boolean isDependedPrimed02, String ResourceArgument) { + RDLSpecDependencyTerm dependencyTerm; + List dependedList = createDependedResourcesList(depended01, isDependedPrimed01, depended02, isDependedPrimed02); + List argumentsList = createConstantArgumentList(constantArgument, depended01); + argumentsList.add(getResource(ResourceArgument)); + dependencyTerm = new RDLSpecDependencyTerm(getResource(depending, isDependingPrimed), dependedList, argumentsList); + + return dependencyTerm; + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificEventHandler.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificEventHandler.java new file mode 100644 index 0000000..1ca9712 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificEventHandler.java @@ -0,0 +1,63 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; + +import java.util.List; + +public class AppSpecificEventHandler extends AppSpecific { + + public AppSpecificEventHandler() { + addEquationFormula(createChangedScreenEquation("editButton", "一覧画面", "編集画面")); + addEquationFormula(createChangedScreenEquation("updateButton", "編集画面", "一覧画面")); + addEquationFormula(createChangedColumnValueEquationByClicked("0", "顧客", "editButton", "編集画面", "wText", "nameInput", "編集画面")); + } + + //ex: [depending : dependedTerm -> constantArgument] + private RDLSpecDependencyTerm createNestedDependencyTermFromTerm(String depending, boolean isDependingPrimed, RDLSpecEvaluatableTerm dependedTerm, String constantArgument) { + RDLSpecDependencyTerm dependencyTerm; + + List dependedList = List.of(dependedTerm); + List argumentsList = List.of(spec.getConstant(constantArgument, RDLSpecLang.typeString)); + dependencyTerm = new RDLSpecDependencyTerm(getResource(depending, isDependingPrimed), dependedList, argumentsList); + return dependencyTerm; + } + + //ex: [[curScId' : [[wState : wId' -> "editButton"] : scId` -> "一覧画面"] -> "clicked"] = "編集画面" + private RDLSpecEquationFormula createChangedScreenEquation(String wId, String curScId, String nextScId) { + RDLSpecEquationFormula equationFormula; + RDLSpecDependencyTerm dependedStateDependencyTerm = createStateDependencyTerm(wId, curScId); + RDLSpecDependencyTerm curScreenDependencyTerm = createNestedDependencyTermFromTerm("curScId", true, dependedStateDependencyTerm, "clicked"); + + equationFormula = new RDLSpecEquationFormula(curScreenDependencyTerm, spec.getConstant(nextScId, RDLSpecLang.typeString)); + + return equationFormula; + } + + //ex: [[[columnValue : columnNo -> 0, key -> curKey] : tableId -> "顧客"] : [[wState : wid' -> "updateButton"] : scId' -> "編集画面"] -> "clicked"] = [[wText : wId' -> "nameInput"] : scId' -> curScId] + private RDLSpecEquationFormula createChangedColumnValueEquationByClicked(String columnNum, String tableIdName, String stateWIdName, String stateCurScIdName, String metaIdName, String metaWIdName, String metaCurScIdName) { + RDLSpecEquationFormula equationFormula; + RDLSpecDependencyTerm columnValueDependencyTerm = createColumnValueDependencyTerm(columnNum, tableIdName); + RDLSpecDependencyTerm dependedStateDependencyTerm = createStateDependencyTerm(stateWIdName, stateCurScIdName); + RDLSpecDependencyTerm leftTerm = new RDLSpecDependencyTerm(columnValueDependencyTerm, List.of(dependedStateDependencyTerm), List.of(spec.getConstant("clicked", RDLSpecLang.typeString))); + RDLSpecDependencyTerm rightTerm = createWidgetMetaIdDependencyTerm(metaIdName, metaWIdName, metaCurScIdName, true); + + equationFormula = new RDLSpecEquationFormula(leftTerm, rightTerm); + + return equationFormula; + } + + //ex: [[wText : wId' -> "memoInput"] : scId' -> "メモ編集画面"] : [[wState : wId' -> "editButton"] : scId' -> "メモ編集画面"] -> "clicked"] = [[wText : wId' -> "memo"] : scId' -> "メモ表示画面"] + private RDLSpecEquationFormula createChangedWidgetTextOverScreenEquationByClicked(String changedMetaIdName, String changedWIdName, String changedScIdName, String triggerWIdName, String triggerScIdName, String metaIdName, String wIdName, String scIdName) { + RDLSpecEquationFormula equationFormula; + RDLSpecDependencyTerm changedWidgetMetaIdDependencyTerm = createWidgetMetaIdDependencyTerm(changedMetaIdName, changedWIdName, changedScIdName, true); + RDLSpecDependencyTerm dependedStateDependencyTerm = createStateDependencyTerm(triggerWIdName, triggerScIdName); + RDLSpecDependencyTerm leftTerm = new RDLSpecDependencyTerm(changedWidgetMetaIdDependencyTerm, List.of(dependedStateDependencyTerm), List.of(spec.getConstant("clicked", RDLSpecLang.typeString))); + RDLSpecDependencyTerm rightTerm = createWidgetMetaIdDependencyTerm(metaIdName, wIdName, scIdName, true); + + equationFormula = new RDLSpecEquationFormula(leftTerm, rightTerm); + + return equationFormula; + + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificInitialValue.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificInitialValue.java new file mode 100644 index 0000000..c795ad8 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificInitialValue.java @@ -0,0 +1,35 @@ +package org.ntlab.rdlcanvas.generaterdl; + + +import org.ntlab.rdlcanvas.models.RDLSpecDependencyTerm; +import org.ntlab.rdlcanvas.models.RDLSpecEquationFormula; + +public class AppSpecificInitialValue extends AppSpecific { + + public AppSpecificInitialValue() { + addEquationFormula(createWidgetEquationWithColumnValue("wText", "nameInput", "編集画面", false , "0", "顧客")); + addEquationFormula(createWidgetEquationWithColumnValue("wText", "nameInput", "編集画面", true, "0", "顧客")); + } + + // [[metaId : wId -> wIdName] : scId -> scIdName] = [[columnValue : columnNo -> columnNum, key -> curKey] : tabled -> tableIdName] + private RDLSpecEquationFormula createWidgetEquationWithColumnValue(String metaId, String wIdName, String scIdName, boolean Primed, String columnNum, String tableIdName) { + RDLSpecEquationFormula equationFormula; + RDLSpecDependencyTerm widgetDependencyTerm; + + if (Primed) { + widgetDependencyTerm = createWidgetMetaIdDependencyTerm(metaId, wIdName, scIdName, true); + } else { + widgetDependencyTerm = createWidgetMetaIdDependencyTerm(metaId, wIdName, scIdName, false); + } + RDLSpecDependencyTerm columnValueDependencyTerm = createColumnValueDependencyTerm(columnNum, tableIdName); + + + equationFormula = new RDLSpecEquationFormula(widgetDependencyTerm, columnValueDependencyTerm); + return equationFormula; + } + + + + + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificScreen.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificScreen.java new file mode 100644 index 0000000..f19f66d --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificScreen.java @@ -0,0 +1,53 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; +import org.ntlab.rdlcanvas.parser.JsonValue; +import org.ntlab.rdlcanvas.parser.StringValue; +import org.ntlab.rdlcanvas.parser.Value; + +import java.util.Map; + +public class AppSpecificScreen extends AppSpecific { + + // parser済みのJsonを引数とする + public AppSpecificScreen(JsonValue value) { + System.out.println(value.toString()); + addScreenRDL(value); + } + + // Jsonを構成するデータを抽出する + private void addScreenRDL(JsonValue value) { + + Map screenMap = value.getKeyToValue(); + + for (StringValue key1 : screenMap.keySet()) { + String scIdString = key1.getStringValue(); //ScreenIDをStringValue(key1)からStringに変換 + Value widgets = screenMap.get(key1); + Map widgetMap = ((org.ntlab.rdlcanvas.parser.JsonValue) widgets).getKeyToValue(); + + for (StringValue key2 : widgetMap.keySet()) { + String wIdString = key2.getStringValue(); //widgetIDをStringValue(key2)からStringに変換 + Value metas = widgetMap.get(key2); + Map metaMap = ((org.ntlab.rdlcanvas.parser.JsonValue) metas).getKeyToValue(); + + for (StringValue key3 : metaMap.keySet()) { + String metaIdString = key3.getStringValue(); //MetaIDをStringValue(key3)からStringへ変換 + Value data = metaMap.get(key3); //Dataを取得 +// System.out.println(metaIdString); + addInitializationFormula(createScreenInitialization(metaIdString, wIdString, scIdString, false, data)); + } + } + } + } + + + //ex [[wText : wId -> "editBotton"] : scId -> "一覧画面"] := "編集" + private RDLSpecInitialization createScreenInitialization(String metaId, String wIdName, String scIdName, boolean isPrimed, Value initializeValue) { + RDLSpecInitialization initialization; + RDLSpecDependencyTerm left = createWidgetMetaIdDependencyTerm(metaId, wIdName, scIdName, isPrimed); + + initialization = new RDLSpecInitialization(left, spec.getConstant(initializeValue.toString(), checkValueType(initializeValue))); + + return initialization; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificTable.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificTable.java new file mode 100644 index 0000000..30cf199 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppSpecificTable.java @@ -0,0 +1,71 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; +import org.ntlab.rdlcanvas.parser.ArrayValue; +import org.ntlab.rdlcanvas.parser.JsonValue; +import org.ntlab.rdlcanvas.parser.StringValue; +import org.ntlab.rdlcanvas.parser.Value; + +import java.util.List; +import java.util.Map; + +public class AppSpecificTable extends AppSpecific { + + public AppSpecificTable(JsonValue value) { + System.out.println(value.toString()); + addTableRDL(value); + } + + public void addTableRDL(JsonValue value) { + + Map tableMap = value.getKeyToValue(); + + + for (StringValue key1 : tableMap.keySet()) { + String tableNameString = key1.getStringValue(); + Value meta = tableMap.get(key1); + Map metaMap = ((org.ntlab.rdlcanvas.parser.JsonValue) meta).getKeyToValue(); + for (StringValue key2 : metaMap.keySet()) { + String metaIdString = key2.getStringValue(); + Value data = metaMap.get(key2); + + if (metaIdString.equals("keyName")) { + addEquationFormula(createKeyNameEquation(tableNameString, data)); + } else if (metaIdString.equals("columnName")) { + if (data instanceof ArrayValue) { + List dataList = ((ArrayValue) data).getValues(); + int index = 0; //columnNo用のindex + for (Value v : dataList) { + if (v instanceof StringValue) { + addEquationFormula(createColumnNameEquation(Integer.toString(index), tableNameString, v)); + } + index++; + } + } + } + } + } + + } + + //ex: [keyName : tableId -> "顧客"] = "顧客ID" + public RDLSpecEquationFormula createKeyNameEquation(String tableIdName, Value value) { + RDLSpecEquationFormula equationFormula; + RDLSpecDependencyTerm dependencyTerm = createDependencyTerm("keyName", false, "tableId", false, tableIdName); + + equationFormula = new RDLSpecEquationFormula(dependencyTerm, spec.getConstant(value.toString(), checkValueType(value))); + + return equationFormula; + } + + //ex: [columnName : columnNo -> 0] : tableId -> "顧客"] = "顧客名" + public RDLSpecEquationFormula createColumnNameEquation(String columnNum, String tableIdName, Value value) { + RDLSpecEquationFormula equationFormula; + RDLSpecDependencyTerm nestedDependencyTerm = createNestedDependencyTermFromTerm(createDependencyTerm("columnName", false, "columnNo", false, columnNum), "tableId", false, tableIdName); + + equationFormula = new RDLSpecEquationFormula(nestedDependencyTerm, spec.getConstant(value.toString(), checkValueType(value))); + + return equationFormula; + + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/GeneratorBase.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/GeneratorBase.java new file mode 100644 index 0000000..6c7302f --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/GeneratorBase.java @@ -0,0 +1,235 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; +import org.ntlab.rdlcanvas.parser.BooleanValue; +import org.ntlab.rdlcanvas.parser.IntegerValue; +import org.ntlab.rdlcanvas.parser.StringValue; +import org.ntlab.rdlcanvas.parser.Value; + +import java.util.ArrayList; +import java.util.List; + +public class GeneratorBase { + + static protected RDLSpec spec; + + public GeneratorBase() { + } + + //specの初期化 + public static void resetSpec() { + spec = new RDLSpec(); + } + + //specの取得 + public static RDLSpec getSpec() { + return spec; + } + + public ValueType checkValueType(Value value) { + if (value instanceof StringValue) { + return RDLSpecLang.typeString; + } else if (value instanceof IntegerValue) { + return RDLSpecLang.typeInt; + } else if (value instanceof BooleanValue) { + return RDLSpecLang.typeBoolean; + } + return RDLSpecLang.typeDouble; + } + + //id型のResourceを取得するためのメソッド + public RDLSpecResource getResource(String resourceName, boolean isPrimed) { + if (isPrimed) { + return spec.getRDLSpecResourceDeclaration(resourceName).getPrimedResource(); + } else { + return spec.getRDLSpecResourceDeclaration(resourceName).getResource(); + } + } + + //id型以外のResourceを取得するためのメソッド + public RDLSpecResource getResource(String resourceName) { + return spec.getRDLSpecResourceDeclaration(resourceName).getResource(); + } + + //RDL式を作成するためのList(dependedはListで渡す必要があるため) + public List createDependedResourceList(String depended, boolean isDependedPrimed) { + List dependedResourceList = new ArrayList<>(); + dependedResourceList.add(getResource(depended, isDependedPrimed)); + + return dependedResourceList; + } + + //RDL式を作成するためのList(dependedはListで渡す必要があるため) dependedが2つある場合 + public List createDependedResourcesList(String depended01, boolean isDependedPrimed01, String depended02, boolean isDependedPrimed02) { + List dependedResourcesList = new ArrayList<>(); + dependedResourcesList.add(getResource(depended01, isDependedPrimed01)); + dependedResourcesList.add(getResource(depended02, isDependedPrimed02)); + + return dependedResourcesList; + } + + // DependencyTerm用のArgument(Constant)リスト + public List createConstantArgumentList(String argument, String dependedId) { + List argumentList = new ArrayList<>(); + argumentList.add(spec.getConstant(argument, spec.getRDLSpecResourceDeclaration(dependedId).getResource().getValueType())); + + return argumentList; + } + + // DependencyTerm用のArgument(Constant)リスト argumentが2つある場合 + public List createConstantArgumentsList(String argument01, String dependedId01, String argument02, String dependedId02) { + List argumentsList = new ArrayList<>(); + argumentsList.add(spec.getConstant(argument01, spec.getRDLSpecResourceDeclaration(dependedId01).getResource().getValueType())); + argumentsList.add(spec.getConstant(argument02, spec.getRDLSpecResourceDeclaration(dependedId02).getResource().getValueType())); + + return argumentsList; + } + + // depending : depended + public RDLSpecDependency createDependency(String depending, boolean isDependingPrimed, String depended, boolean isDependedPrimed) { + RDLSpecDependency dependency; + List dependedList = createDependedResourceList(depended, isDependedPrimed); + dependency = new RDLSpecDependency(getResource(depending, isDependingPrimed), dependedList); + + return dependency; + } + + // depending : depended01, depended02 + public RDLSpecDependency createDependency(String depending, boolean isDependingPrimed, String depended01, boolean isDependedPrimed01, String depended02, boolean isDependedPrimed02) { + RDLSpecDependency dependency; + List dependedList = createDependedResourcesList(depended01, isDependedPrimed01, depended02, isDependedPrimed02); + dependency = new RDLSpecDependency(getResource(depending, isDependingPrimed), dependedList); + + return dependency; + } + + // [depending : insideDepended]:outsideDepended + public RDLSpecDependency createNestedDependency(String depending, boolean isDependingPrimed, String insideDepended, boolean isInsideDependedPrimed, String outsideDepended, boolean isOutsideDependedPrimed) { + RDLSpecDependency nestedDependency; + RDLSpecDependency insideDependency = createDependency(depending, isDependingPrimed, insideDepended, isInsideDependedPrimed); + List outsideDependedList = createDependedResourceList(outsideDepended, isOutsideDependedPrimed); + + nestedDependency = new RDLSpecDependency(insideDependency, outsideDependedList); + + return nestedDependency; + + } + + // [depending : depended01, depended02] : outsideDepended + public RDLSpecDependency createNestedDependency(String depending, boolean isDependingPrimed, String depended01, boolean isDependedPrimed01, String depended02, boolean isDependedPrimed02, String outsideDepended, boolean isOutsideDependedPrimed) { + RDLSpecDependency nestedDependency; + RDLSpecDependency dependingDependency = createDependency(depending, isDependingPrimed, depended01, isDependedPrimed01, depended02, isDependedPrimed02); + List outsideDependedList = createDependedResourceList(outsideDepended, isOutsideDependedPrimed); + + nestedDependency = new RDLSpecDependency(dependingDependency, outsideDependedList); + + return nestedDependency; + } + + // [depending : depended -> constantArgument] (dependingがid型の場合) + public RDLSpecDependencyTerm createDependencyTerm(String depending, boolean isDependingPrimed, String depended, boolean isDependedPrimed, String constantArgument) { + RDLSpecDependencyTerm dependencyTerm; + List dependedList = createDependedResourceList(depended, isDependedPrimed); + List arguemntsList = createConstantArgumentList(constantArgument, depended); + + dependencyTerm = new RDLSpecDependencyTerm(getResource(depending, isDependingPrimed), dependedList, arguemntsList); + + return dependencyTerm; + } + + // [depending : depended -> constantArgument] (dependingがid型以外の場合) + public RDLSpecDependencyTerm createDependencyTerm(String depending, String depended, boolean isDependedPrimed, String constantArgument) { + RDLSpecDependencyTerm dependencyTerm; + List dependedList = createDependedResourceList(depended, isDependedPrimed); + List arguemntsList = createConstantArgumentList(constantArgument, depended); + + dependencyTerm = new RDLSpecDependencyTerm(getResource(depending), dependedList, arguemntsList); + + return dependencyTerm; + } + + // [depending : depended01 -> constantArgument01, depended02 -> constantArgument02] + public RDLSpecDependencyTerm createDependencyTerm(String depending, boolean isDependingPrimed, String depended01, boolean isDependedPrimed01, String constantArgument01, String depended02, boolean isDependedPrimed02, String constantArgument02) { + RDLSpecDependencyTerm dependencyTerm; + List dependedList = createDependedResourcesList(depended01, isDependedPrimed01, depended02, isDependedPrimed02); + List argumentsList = createConstantArgumentsList(constantArgument01, depended01, constantArgument02, depended02); + dependencyTerm = new RDLSpecDependencyTerm(getResource(depending, isDependingPrimed), dependedList, argumentsList); + + return dependencyTerm; + } + + // [depending : dependedList -> argumentsList] + public RDLSpecDependencyTerm createDependencyTerm(String depending, boolean isDependingPrimed, List depenededList, List argumentsList) { + RDLSpecDependencyTerm dependencyTerm; + dependencyTerm = new RDLSpecDependencyTerm(getResource(depending, isDependingPrimed), depenededList, argumentsList); + + return dependencyTerm; + } + + // [(dependencyTerm) : depended -> constantArgument] + public RDLSpecDependencyTerm createNestedDependencyTermFromTerm(RDLSpecEvaluatableTerm dependingTerm, String depended, boolean isDependedPrimed, String constantArgument) { + RDLSpecDependencyTerm dependencyTerm; + + List dependedList = createDependedResourceList(depended, isDependedPrimed); + List arguementsList; + if (spec.getRDLSpecResourceDeclaration(constantArgument) == null) { + arguementsList = createConstantArgumentList(constantArgument, depended); + } else { + arguementsList = createDependedResourceList(constantArgument, false); + } + dependencyTerm = new RDLSpecDependencyTerm(dependingTerm, dependedList, arguementsList); + + return dependencyTerm; + } + + // [(dependencyTerm) : depended01 -> constantArgument01, depended02 -> constantArgument02] + public RDLSpecDependencyTerm createNestedDependencyTermFromTerm(RDLSpecEvaluatableTerm dependingTerm, String depended01, boolean isDependedPrimed01, String constantArgument01, String depended02, boolean isDependedPrimed02, String constantArgument02) { + RDLSpecDependencyTerm dependencyTerm; + List dependedList = createDependedResourcesList(depended01, isDependedPrimed01, depended02, isDependedPrimed02); + List argumentList = createConstantArgumentsList(constantArgument01, depended01, constantArgument02, depended02); + dependencyTerm = new RDLSpecDependencyTerm(dependingTerm, dependedList, argumentList); + + return dependencyTerm; + } + + // [(dependencyTerm) : dependedList -> argumentsList] + public RDLSpecDependencyTerm createNestedDependencyTermFromTerm(RDLSpecEvaluatableTerm dependingTerm, List depenededList, List argumentsList) { + RDLSpecDependencyTerm dependencyTerm; + dependencyTerm = new RDLSpecDependencyTerm(dependingTerm, depenededList, argumentsList); + + return dependencyTerm; + } + + + // [depending: insideDepended -> insideConstantArgument] : outsideDepended -> outsideConstantArgument] + public RDLSpecDependencyTerm createNestedDependencyTerm(String depending, boolean isDependingPrimed, String insideDepended, boolean isInsideDependedPrimed, String insideConstantArgument, String outsideDepended, boolean isOutsideDependedPrimed, String outsideConstantArgument) { + RDLSpecDependencyTerm nestedDependencyTerm; + RDLSpecDependencyTerm insideDependencyTerm = createDependencyTerm(depending, isDependingPrimed, insideDepended, isInsideDependedPrimed, insideConstantArgument); + + nestedDependencyTerm = createNestedDependencyTermFromTerm(insideDependencyTerm, outsideDepended, isOutsideDependedPrimed, outsideConstantArgument); + + return nestedDependencyTerm; + } + + + // RDLSpecDependencyをFormula化してspecに追加 + public void addDependencyFormula(RDLSpecDependency rdlSpecDependency) { + + RDLSpecDependencyFormula rdlSpecDependencyFormula = new RDLSpecDependencyFormula(rdlSpecDependency); + spec.addRDLSpecStatement(rdlSpecDependencyFormula); + } + + //EquationFormulaをspecに追加 + public void addEquationFormula(RDLSpecEquationFormula rdlSpecEquationFormula) { + + spec.addRDLSpecStatement(rdlSpecEquationFormula); + } + + //InitializationFormulaをspecに追加 + public void addInitializationFormula(RDLSpecInitialization rdlInitializationFormula) { + + spec.addRDLSpecStatement(rdlInitializationFormula); + } + + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/Meta.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/Meta.java new file mode 100644 index 0000000..d8b3f75 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/Meta.java @@ -0,0 +1,23 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.StructuralType; +import org.ntlab.rdlcanvas.models.ValueType; + +public class Meta extends GeneratorBase { + public Meta() { + + } + + // name(order) :: structuralType, valueType specに追加 + public void addResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + spec.addRDLSpecResourceDeclaration(name, order, structuralType, valueType); + spec.addRDLSpecStatement(spec.getRDLSpecResourceDeclaration(name)); + } + + // name(order) :: valueType specに追加 + public void addResourceDeclaration(String name, int order, ValueType valueType) { + spec.addRDLSpecResourceDeclaration(name, order, valueType); + spec.addRDLSpecStatement(spec.getRDLSpecResourceDeclaration(name)); + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreen.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreen.java new file mode 100644 index 0000000..a02bbb6 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreen.java @@ -0,0 +1,52 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; + +import java.util.ArrayList; +import java.util.List; + + +public class MetaScreen extends Meta { + + ArrayList metaIdList = new ArrayList<>(List.of("wText", "wType", "wState", "wX", "wY", "wWidth", "wHeight", "wEnabled", "wVisible", "wColor")); + + public MetaScreen() { + addScreenTemplateResourceDeclaration(); + addScreenTemplateDependencyFormula(); + } + + private void addScreenTemplateResourceDeclaration() { + + //ex screen(1) :: struct + addResourceDeclaration("screen", 1, StructuralType.structure, null); + addResourceDeclaration("scId", 1, StructuralType.id, RDLSpecLang.typeString); + addResourceDeclaration("widget", 2, StructuralType.structure, null); + addResourceDeclaration("wId", 2, StructuralType.id, RDLSpecLang.typeString); + addResourceDeclaration("wText", 2, RDLSpecLang.typeString); + addResourceDeclaration("wType", 2, RDLSpecLang.typeString); + addResourceDeclaration("wState", 2, RDLSpecLang.typeString); + addResourceDeclaration("wX", 2, RDLSpecLang.typeInt); + addResourceDeclaration("wY", 2, RDLSpecLang.typeInt); + addResourceDeclaration("wWidth", 2, RDLSpecLang.typeInt); + addResourceDeclaration("wHeight", 2, RDLSpecLang.typeInt); + addResourceDeclaration("wEnabled", 2, RDLSpecLang.typeBoolean); + addResourceDeclaration("wVisible", 2, RDLSpecLang.typeBoolean); + addResourceDeclaration("wColor", 2, RDLSpecLang.typeString); + } + + private void addScreenTemplateDependencyFormula() { + + //ex screen:scId + addDependencyFormula(createDependency("screen", false, "scId", false)); + addDependencyFormula(createDependency("screen", false, "scId", true)); + for (String mId : metaIdList) { + addDependencyFormula(createDependency(mId, false, "widget", false)); + } + + // [widget:wid]:screen + addDependencyFormula(createNestedDependency("widget", false,"wId", false, "screen", false)); + + } + + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenView.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenView.java new file mode 100644 index 0000000..4f854e3 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenView.java @@ -0,0 +1,53 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; + +import java.util.List; + +public class MetaScreenView extends Meta { + + public MetaScreenView() { + addScreenViewResourceDeclaration(); + addScreenViewDependencyFormula(); + addEquationFormula(createScreenViewEquationFormula()); + } + + private void addScreenViewResourceDeclaration() { + + // ex curWidget(1)::struct + addResourceDeclaration("curWidget", 1, StructuralType.structure, null); + addResourceDeclaration("curWId", 1, StructuralType.id, RDLSpecLang.typeString); + addResourceDeclaration("curWText", 1, RDLSpecLang.typeString); + addResourceDeclaration("curWState", 1, RDLSpecLang.typeString); + addResourceDeclaration("curScId", 0, StructuralType.id, RDLSpecLang.typeString); + + } + + private void addScreenViewDependencyFormula() { + + // ex curWidget:curWId + addDependencyFormula(createDependency("curWidget", false, "curWId", false)); + addDependencyFormula(createDependency("curWidget", false, "curWId", true)); + addDependencyFormula(createDependency("curWText", false, "curWidget", false)); + addDependencyFormula(createDependency("curWState", false, "curWidget", false)); + + } + + // curWidget = [[widget:wId->curWId]:scId->curScId, curWId->curWId] + private RDLSpecEquationFormula createScreenViewEquationFormula() { + + RDLSpecEquationFormula equationFormula; + List insideDependedList = createDependedResourceList("wId", false); + List insideArgumentList = createDependedResourceList("curWId", false); + RDLSpecDependencyTerm insideDependencyTerm = createDependencyTerm("widget", false, insideDependedList, insideArgumentList); + + List outsideDependedsList = createDependedResourcesList("scId", false, "curWId", false); + List outsideArgumentsList = createDependedResourcesList("curScId", false, "curWId", false); + RDLSpecDependencyTerm outsideDependencyTerm = createNestedDependencyTermFromTerm(insideDependencyTerm, outsideDependedsList, outsideArgumentsList); + + equationFormula = new RDLSpecEquationFormula(getResource("curWidget", false), outsideDependencyTerm); + + return equationFormula; + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTable.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTable.java new file mode 100644 index 0000000..1098c7a --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTable.java @@ -0,0 +1,39 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; + +public class MetaTable extends Meta { + + public MetaTable() { + addMetaTableResourceDeclaration(); + addMetaTableDependencyFormula(); + } + + private void addMetaTableResourceDeclaration() { + + // ex table(1)::structure + addResourceDeclaration("table", 1, StructuralType.structure, null); + addResourceDeclaration("tableId", 1, StructuralType.id, RDLSpecLang.typeString); + addResourceDeclaration("keyName", 1, RDLSpecLang.typeString); + addResourceDeclaration("curKey", 1, RDLSpecLang.typeString); + addResourceDeclaration("columnName", 2, RDLSpecLang.typeString); + addResourceDeclaration("columnNo", 2, StructuralType.id, RDLSpecLang.typeInt); + addResourceDeclaration("columnValue", 2, RDLSpecLang.typeString); + addResourceDeclaration("key", 2, StructuralType.id, RDLSpecLang.typeString); + + } + + private void addMetaTableDependencyFormula() { + + // ex table : tableId + addDependencyFormula(createDependency("table", false, "tableId", false)); + addDependencyFormula(createDependency("table", false, "tableId", true)); + addDependencyFormula(createDependency("keyName", false, "table", false)); + addDependencyFormula(createDependency("curKey", false, "table", false)); + + addDependencyFormula(createNestedDependency("columnName",false, "columnNo", false, "table", false)); + addDependencyFormula(createNestedDependency("columnValue",false, "columnNo", false, "key", false, "table", false)); + } + + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGenerator.java new file mode 100644 index 0000000..c1925d6 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGenerator.java @@ -0,0 +1,44 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.RDLSpec; +import org.ntlab.rdlcanvas.parser.JsonValue; +import org.ntlab.rdlcanvas.parser.Parser; +import org.ntlab.rdlcanvas.parser.StringValue; + +import java.io.BufferedReader; + +public class RDLGenerator { + + final StringValue VALUE_KEY_SCREEN = new StringValue("screen"); + final StringValue VALUE_KEY_TABLE = new StringValue("table"); + + public RDLGenerator(final BufferedReader reader) { + GeneratorBase.resetSpec(); + generateMetaAppRDL(); + generateSpecificAppRDL(reader); + } + + //メタアプリケーション仕様 + private void generateMetaAppRDL() { + MetaScreen metaScreen = new MetaScreen(); + MetaTable metaTable = new MetaTable(); + MetaScreenView metaScreenView = new MetaScreenView(); + } + + //アプリケーション固有仕様 + private void generateSpecificAppRDL(BufferedReader reader) { + Parser parser = new Parser(reader); + + //JsonValueを取得 + JsonValue jsonValue = parser.parseJsonValue(); + AppSpecificScreen appSpecificScreen = new AppSpecificScreen((JsonValue) jsonValue.getValue(VALUE_KEY_SCREEN)); + AppSpecificTable appSpecificTable = new AppSpecificTable((JsonValue) jsonValue.getValue(VALUE_KEY_TABLE)); + AppSpecificInitialValue appSpecificInitialValue = new AppSpecificInitialValue(); + AppSpecificEventHandler appSpecificEventHandler = new AppSpecificEventHandler(); + + } + + public RDLSpec getSpec() { + return GeneratorBase.getSpec(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java new file mode 100644 index 0000000..1f71897 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java @@ -0,0 +1,94 @@ +package org.ntlab.rdlcanvas.models; + +import java.util.*; + +public class RDLSpec { + private Map resourceMap; + private List rdlSpecStatements; + private Map> rdlSpecResourceConstantMap; + + public RDLSpec() { + resourceMap = new HashMap<>(); + rdlSpecStatements = new ArrayList<>(); + rdlSpecResourceConstantMap = new HashMap<>(); + } + + public void addRDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, structuralType, valueType)); + } + + public void addRDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, valueType)); + } + + public RDLSpecResourceDeclaration getRDLSpecResourceDeclaration(String name) { + if (!resourceMap.containsKey(name)) { + return null; + } + return resourceMap.get(name); + } + + public RDLSpecResourceConstant getConstant(String value, ValueType valueType) { + if (rdlSpecResourceConstantMap.containsKey(value)) { + if (rdlSpecResourceConstantMap.get(value).containsKey(valueType)) { + return rdlSpecResourceConstantMap.get(value).get(valueType); + } else { + rdlSpecResourceConstantMap.get(value).put(valueType,new RDLSpecResourceConstant(value, valueType)); + } + } else { + rdlSpecResourceConstantMap.put(value, new HashMap<>()); + rdlSpecResourceConstantMap.get(value).put(valueType, new RDLSpecResourceConstant(value, valueType)); + } + return rdlSpecResourceConstantMap.get(value).get(valueType); + } + + public RDLSpecResourceConstant getTrue() { + if (!rdlSpecResourceConstantMap.containsKey("true")) { + rdlSpecResourceConstantMap.put("true", new HashMap<>()); + if (!rdlSpecResourceConstantMap.get("true").containsKey(RDLSpecLang.typeBoolean)) { + rdlSpecResourceConstantMap.get("true").put(RDLSpecLang.typeBoolean, new RDLSpecResourceConstant("true", RDLSpecLang.typeBoolean)); + } + } + return rdlSpecResourceConstantMap.get("true").get(RDLSpecLang.typeBoolean); + } + + public RDLSpecResourceConstant getFalse() { + if (!rdlSpecResourceConstantMap.containsKey("false")) { + rdlSpecResourceConstantMap.put("false", new HashMap<>()); + if (!rdlSpecResourceConstantMap.get("false").containsKey(RDLSpecLang.typeBoolean)) { + rdlSpecResourceConstantMap.get("false").put(RDLSpecLang.typeBoolean, new RDLSpecResourceConstant("false", RDLSpecLang.typeBoolean)); + } + } + return rdlSpecResourceConstantMap.get("false").get(RDLSpecLang.typeBoolean); + } + + public void addRDLSpecStatement(RDLSpecStatement rdlSpecStatement) { + rdlSpecStatements.add(rdlSpecStatement); + rdlSpecStatements.sort(Comparator.comparing(obj -> { + if (obj.isRDLSpecResourceDeclaration()) { + return 1; + } + if (obj.isRDLSpecInitialization()) { + return 2; + } + return 3; + })); + } + + public List getRDLSpecStatements() { + return rdlSpecStatements; + } + + public Map getResourceMap() { + return resourceMap; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < rdlSpecStatements.size(); i++) { + sb.append(rdlSpecStatements.get(i)).append("\n"); + } + return sb.toString(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java new file mode 100644 index 0000000..ffd3883 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java @@ -0,0 +1,19 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.Dependency; +import models.terms.EvaluatableTerm; +import models.terms.RDLTerm; + +import java.util.List; + +public class RDLSpecDependency extends Dependency { + + public RDLSpecDependency(RDLSpecDependency dependingTerm, List dependedTerms) { + super(dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + } + + public RDLSpecDependency(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms) { + super((RDLTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java new file mode 100644 index 0000000..2c63007 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java @@ -0,0 +1,20 @@ +package org.ntlab.rdlcanvas.models; + +import models.formulas.DependencyFormula; + +public class RDLSpecDependencyFormula extends DependencyFormula implements RDLSpecStatement { + + public RDLSpecDependencyFormula(RDLSpecDependency dependency) { + super(dependency); + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java new file mode 100644 index 0000000..b6e5cf0 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java @@ -0,0 +1,61 @@ +package org.ntlab.rdlcanvas.models; + +import exceptions.SyntaxException; +import models.terms.DependencyTerm; +import models.terms.EvaluatableTerm; + +import java.util.List; + +public class RDLSpecDependencyTerm extends DependencyTerm implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valuableType; + + public RDLSpecDependencyTerm(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms, List argumentTerms) { + super((EvaluatableTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList(), argumentTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + this.structuralType = ((Typable) dependingTerm).getStructuralType(); + this.valuableType = ((Typable) dependingTerm).getValueType(); + + for (int i = 0; i < dependedTerms.size(); i ++) { + if (!typeChecker(dependedTerms.get(i), argumentTerms.get(i))) { + throw new SyntaxException("the type is different"); + } + } + } + + private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); + + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { + return true; + } else { + return false; + } + } else { + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); + + if (leftValueType.equals(rightValueType)) { + return true; + } else { + return false; + } + } + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valuableType; + } + + @Override + public boolean isDependencyTerm() { + return true; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java new file mode 100644 index 0000000..a367ac1 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java @@ -0,0 +1,47 @@ +package org.ntlab.rdlcanvas.models; + +import exceptions.SyntaxException; +import models.formulas.EquationFormula; +import models.terms.EvaluatableTerm; + +public class RDLSpecEquationFormula extends EquationFormula implements RDLSpecStatement { + + public RDLSpecEquationFormula(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { + super((EvaluatableTerm) leftSideHand, (EvaluatableTerm) rightSideHand); + if (!typeChecker(leftSideHand, rightSideHand)) { + throw new SyntaxException("the type is different"); + } + } + + private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); + + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { + return true; + } else { + return false; + } + } else { + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); + + if (leftValueType.equals(rightValueType)) { + return true; + } else { + return false; + } + } + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java new file mode 100644 index 0000000..32108b9 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java @@ -0,0 +1,5 @@ +package org.ntlab.rdlcanvas.models; + +public interface RDLSpecEvaluatableTerm { + boolean isDependencyTerm(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java new file mode 100644 index 0000000..43627a2 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java @@ -0,0 +1,47 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecInitialization implements RDLSpecStatement { + RDLSpecEvaluatableTerm leftSideHand; + RDLSpecEvaluatableTerm rightSideHand; + + public RDLSpecInitialization(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { + this.leftSideHand = leftSideHand; + this.rightSideHand = rightSideHand; + } + + public RDLSpecEvaluatableTerm getLeftSideHand() { + return leftSideHand; + } + + public RDLSpecEvaluatableTerm getRightSideHand() { + return rightSideHand; + } + + @Override + public boolean isRDLSpecInitialization() { + return true; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } + + @Override + public String toString() { + return leftSideHand + " := " + rightSideHand; + } + + @Override + public boolean equals(Object another) { + if (!(another instanceof RDLSpecInitialization anotherInitialization)) { + return false; + } + return leftSideHand.equals(anotherInitialization.getLeftSideHand()) && rightSideHand.equals(anotherInitialization.getRightSideHand()); + } + + @Override + public int hashCode() { + return toString().hashCode(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java new file mode 100644 index 0000000..ba6ff86 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java @@ -0,0 +1,8 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecLang { + public static final ValueType typeString = new ValueType("string"); + public static final ValueType typeInt = new ValueType("int"); + public static final ValueType typeBoolean = new ValueType("boolean"); + public static final ValueType typeDouble = new ValueType("double"); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java new file mode 100644 index 0000000..9401c33 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java @@ -0,0 +1,49 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.Resource; + +public class RDLSpecResource extends Resource implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valueType; + + public RDLSpecResource(String name, int order, StructuralType structuralType, ValueType valueType) { + super(name, order); + if (!(structuralType == StructuralType.structure || structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.map || structuralType == StructuralType.value)) { + throw new IllegalArgumentException(structuralType + " is not expected structural type."); + } + + if (structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.value) { + if (!(valueType.equals(RDLSpecLang.typeInt) || valueType.equals(RDLSpecLang.typeDouble) || valueType.equals(RDLSpecLang.typeString) || valueType.equals(RDLSpecLang.typeBoolean))) { + throw new IllegalArgumentException(structuralType + " is not expected valuable Type."); + } + } else { + if (valueType != null) { + throw new IllegalArgumentException("It does not have a type"); + } + } + + this.structuralType = structuralType; + this.valueType = valueType; + } + + public RDLSpecResource(String name, int order, ValueType valueType) { + super(name, order); + structuralType = StructuralType.primitive; + this.valueType = valueType; + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valueType; + } + + @Override + public boolean isDependencyTerm() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java new file mode 100644 index 0000000..8050ae8 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java @@ -0,0 +1,38 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.ResourceConstant; + +public class RDLSpecResourceConstant extends ResourceConstant implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valueType; + + public RDLSpecResourceConstant(String value, ValueType valueType) { + super(value); + this.structuralType = StructuralType.primitive; + this.valueType = valueType; + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valueType; + } + + @Override + public boolean isDependencyTerm() { + return false; + } + + @Override + public String toString() { + if (valueType.getName().equals("string")) { + return "\"" + getName() + "\""; + } else { + return getName(); + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java new file mode 100644 index 0000000..eb4204e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java @@ -0,0 +1,76 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecResourceDeclaration implements RDLSpecStatement { + private RDLSpecResource resource; + private RDLSpecResource primedResource; + + public RDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + resource = new RDLSpecResource(name, order, structuralType, valueType); + if (structuralType == StructuralType.id) { + primedResource = new RDLSpecResource(name + "'", order, structuralType, valueType); + } else { + primedResource = null; + } + } + + public RDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resource = new RDLSpecResource(name, order, valueType); + primedResource = null; + } + + public RDLSpecResource getResource() { + return resource; + } + + public RDLSpecResource getPrimedResource() { + return primedResource; + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return true; + } + + @Override + public boolean equals(Object another) { + if (!(another instanceof RDLSpecResourceDeclaration rdlSpecResourceDeclaration)) { + return false; + } + + if (rdlSpecResourceDeclaration.getResource().equals(resource) && ((rdlSpecResourceDeclaration.getPrimedResource() == null && primedResource == null) || rdlSpecResourceDeclaration.getPrimedResource().equals(primedResource))) { + return true; + } else { + return false; + } + } + + @Override + public int hashCode() { + return toString().hashCode(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(resource).append("(").append(resource.getOrder()).append("):: "); + + if (resource.getStructuralType() == StructuralType.primitive) { + sb.append(resource.getValueType().getName()); + return sb.toString(); + } + + if (resource.getValueType() == null) { + sb.append(resource.getStructuralType()); + return sb.toString(); + } else { + sb.append(resource.getStructuralType()); + sb.append(", ").append(resource.getValueType().getName()); + return sb.toString(); + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java new file mode 100644 index 0000000..a2bdd1e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java @@ -0,0 +1,6 @@ +package org.ntlab.rdlcanvas.models; + +public interface RDLSpecStatement { + boolean isRDLSpecResourceDeclaration(); + boolean isRDLSpecInitialization(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java b/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java new file mode 100644 index 0000000..d4efbf7 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java @@ -0,0 +1,26 @@ +package org.ntlab.rdlcanvas.models; + +public enum StructuralType { + id, + value, + structure, + map, + primitive; + + @Override + public String toString() { + switch (this) { + case id: + return "id"; + case value: + return "value"; + case structure: + return "struct"; + case map: + return "map"; + case primitive: + default: + return ""; + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/Typable.java b/src/main/java/org/ntlab/rdlcanvas/models/Typable.java new file mode 100644 index 0000000..7b2e0ac --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/Typable.java @@ -0,0 +1,7 @@ +package org.ntlab.rdlcanvas.models; + + +public interface Typable { + StructuralType getStructuralType(); + ValueType getValueType(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java b/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java new file mode 100644 index 0000000..3939044 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java @@ -0,0 +1,21 @@ +package org.ntlab.rdlcanvas.models; + +public class ValueType { + private String name; + + public ValueType(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof ValueType)) { + return false; + } + return name.equals(((ValueType) obj).name); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/parser/BooleanValue.java b/src/main/java/org/ntlab/rdlcanvas/parser/BooleanValue.java new file mode 100644 index 0000000..10adab1 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/parser/BooleanValue.java @@ -0,0 +1,19 @@ +package org.ntlab.rdlcanvas.parser; + +public class BooleanValue extends Value{ + Boolean booleanValue; + + public void setBooleanValue(String stringValue){ + if(stringValue.equals("true")){ + booleanValue = true; + }else{ + booleanValue = false; + } + } + + @Override + public String toString(){ + return String.valueOf(booleanValue); + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java b/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java index dceac65..252b3a2 100644 --- a/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java +++ b/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java @@ -24,6 +24,8 @@ public static final String COMMA = ","; public static final String COLON = ":"; public static final String DOUBLE_QUOT = "\""; + public static final String TRUE = "true"; + public static final String FALSE = "false"; // Json文字列を標準入力から受け取るコンストラクタ public Parser() { @@ -76,6 +78,8 @@ return parseStringValue(tokenStream); } else if (Character.isDigit(tokenStream.checkNext().charAt(0))) { return parseIntegerValue(tokenStream); + } else if(tokenStream.checkNext().equals(TRUE) || tokenStream.checkNext().equals(FALSE)){ + return parseBooleanValue(tokenStream); } throw new RuntimeException(String.valueOf(tokenStream.getLine())); } @@ -179,6 +183,16 @@ return stringValue; } + public BooleanValue parseBooleanValue(TokenStream tokenstream){ + BooleanValue booleanValue = new BooleanValue(); + StringBuilder stringBuilder = new StringBuilder(); + while(!(stringBuilder.toString().equals(TRUE)||stringBuilder.toString().equals(FALSE))){ + stringBuilder.append(tokenstream.next()); + } + booleanValue.setBooleanValue(stringBuilder.toString()); + return booleanValue; + } + public void expect(TokenStream tokenStream, String expect) { if (!tokenStream.checkNext().equals(expect)) { throw new RuntimeException("expect" + expect + "but" + tokenStream.checkNext() + " line" + tokenStream.getLine()); diff --git a/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java b/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java index f04ea6f..a4a2678 100644 --- a/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java +++ b/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java @@ -22,7 +22,7 @@ // 文字列をtoStringメゾットとして返す @Override public String toString() { - return stringValue; + return stringValue ; } @Override diff --git a/src/main/java/org/ntlab/rdlcanvas/rdlgenerator/RDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/rdlgenerator/RDLGenerator.java deleted file mode 100644 index c7990c7..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/rdlgenerator/RDLGenerator.java +++ /dev/null @@ -1,4 +0,0 @@ -package org.ntlab.rdlcanvas.rdlgenerator; - -public class RDLGenerator { -}