diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUnique.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUnique.java new file mode 100644 index 0000000..ca8fb00 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUnique.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 AppUnique extends GeneratorBase { + + + public AppUnique() { + + } + + // [[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/AppUniqueEventHandler.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueEventHandler.java new file mode 100644 index 0000000..56b8fd0 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueEventHandler.java @@ -0,0 +1,48 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; + +import java.util.List; + +public class AppUniqueEventHandler extends AppUnique { + + public AppUniqueEventHandler() { + 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; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueInitialValue.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueInitialValue.java new file mode 100644 index 0000000..5770f3d --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueInitialValue.java @@ -0,0 +1,35 @@ +package org.ntlab.rdlcanvas.generaterdl; + + +import org.ntlab.rdlcanvas.models.RDLSpecDependencyTerm; +import org.ntlab.rdlcanvas.models.RDLSpecEquationFormula; + +public class AppUniqueInitialValue extends AppUnique { + + public AppUniqueInitialValue() { + 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/AppUniqueScreen.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueScreen.java new file mode 100644 index 0000000..caa3751 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueScreen.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 AppUniqueScreen extends AppUnique { + + // parser済みのJsonを引数とする + public AppUniqueScreen(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/AppUniqueTable.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueTable.java new file mode 100644 index 0000000..f4b2bfc --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/AppUniqueTable.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 AppUniqueTable extends AppUnique { + + public AppUniqueTable(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, "columnName", 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/BaseGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/BaseGenerateRDL.java deleted file mode 100644 index 31c1f27..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/BaseGenerateRDL.java +++ /dev/null @@ -1,53 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; -import org.ntlab.rdlcanvas.parser.Value; - -import java.util.ArrayList; - -public class BaseGenerateRDL { - - public ValueType checkValueType(Value value) { - if (value.getClass().getSimpleName().equals("StringValue")) { - return RDLSpecLang.typeString; - } else if (value.getClass().getSimpleName().equals("IntegerValue")) { - return RDLSpecLang.typeInt; - } else if (value.getClass().getSimpleName().equals("BooleanValue")) { - return RDLSpecLang.typeBoolean; - } - return RDLSpecLang.typeDouble; - } - - // [depending: insideDependedId -> insideArguments] : outsideDependedId -> outsideArguments] - public RDLSpecDependencyTerm createNestedDependencyTerm(RDLSpec spec, String depending, String insideDependedId, boolean insideDependedIdPrime, String insideArgument, String outsideDependedId, boolean outsideDependedIdPrime, String outsideArgument){ - - ArrayList insideDependedResourceList = new ArrayList<>(); - ArrayList insideArgumentsList = new ArrayList<>(); - ArrayList outsideDependedResourceList = new ArrayList<>(); - ArrayList outsideArgumentsList = new ArrayList<>(); - - insideArgumentsList.add(spec.getConstant(insideArgument, spec.getRDLSpecResourceDeclaration(insideDependedId).getResource().getValueType())); - outsideArgumentsList.add(spec.getConstant(outsideArgument, spec.getRDLSpecResourceDeclaration(outsideDependedId).getResource().getValueType())); - - if(insideDependedIdPrime){ - insideDependedResourceList.add(spec.getRDLSpecResourceDeclaration(insideDependedId).getPrimedResource()); - }else{ - insideDependedResourceList.add(spec.getRDLSpecResourceDeclaration(insideDependedId).getResource()); - } - - if(outsideDependedIdPrime){ - outsideDependedResourceList.add(spec.getRDLSpecResourceDeclaration(outsideDependedId).getPrimedResource()); - }else { - outsideDependedResourceList.add(spec.getRDLSpecResourceDeclaration(outsideDependedId).getResource()); - } - - - RDLSpecDependencyTerm insideDependencyTerm = new RDLSpecDependencyTerm(spec.getRDLSpecResourceDeclaration(depending).getResource(), insideDependedResourceList, insideArgumentsList); - RDLSpecDependencyTerm outsideDependencyTerm = new RDLSpecDependencyTerm(insideDependencyTerm, outsideDependedResourceList, outsideArgumentsList); - - - return outsideDependencyTerm; - } - - -} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/BaseMetaGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/BaseMetaGenerateRDL.java deleted file mode 100644 index 16d7507..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/BaseMetaGenerateRDL.java +++ /dev/null @@ -1,69 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -import java.util.ArrayList; -import java.util.List; - -public class BaseMetaGenerateRDL { - - - // name(order)::structuralType, valueType - public void addResourceDeclaration(RDLSpec spec, String name, int order, StructuralType structuralType, ValueType valueType){ - spec.addRDLSpecResourceDeclaration(name, order, structuralType, valueType); - spec.addRDLSpecStatement(spec.getRDLSpecResourceDeclaration(name)); - } - - // name(order)::valueType - public void addResourceDeclaration(RDLSpec spec, String name, int order, ValueType valueType){ - spec.addRDLSpecResourceDeclaration(name, order, valueType); - spec.addRDLSpecStatement(spec.getRDLSpecResourceDeclaration(name)); - } - - - // depending:depended - public void addElementPairDependencyFormula(RDLSpec spec, String depending, boolean dependingPrimed, String depended, boolean dependedPrimed){ - - List dependedList = new ArrayList<>(); - - if(dependedPrimed) { - dependedList.add(spec.getRDLSpecResourceDeclaration(depended).getPrimedResource()); - } else { - dependedList.add(spec.getRDLSpecResourceDeclaration(depended).getResource()); - } - - if(dependingPrimed){ - RDLSpecDependencyFormula rdlSpecDependencyFormula = new RDLSpecDependencyFormula(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getPrimedResource(), dependedList)); - spec.addRDLSpecStatement(rdlSpecDependencyFormula); - } else { - RDLSpecDependencyFormula rdlSpecDependencyFormula = new RDLSpecDependencyFormula(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedList)); - spec.addRDLSpecStatement(rdlSpecDependencyFormula); - } - - } - - // [depending:depended]:outsideDepended - public void addNestedDependencyFormula(RDLSpec spec, String depending, boolean dependingPrimed, String depended, boolean dependedPrimed, String outsideDepended, boolean outsideDependedPrimed){ - List dependedInsideList = new ArrayList<>(); - List dependedOutsideList = new ArrayList<>(); - - if(dependedPrimed){ - dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended).getPrimedResource()); - }else{ - dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended).getResource()); - } - - if(outsideDependedPrimed){ - dependedOutsideList.add(spec.getRDLSpecResourceDeclaration(outsideDepended).getPrimedResource()); - }else{ - dependedOutsideList.add(spec.getRDLSpecResourceDeclaration(outsideDepended).getResource()); - } - - if(dependingPrimed){ - spec.addRDLSpecStatement(new RDLSpecDependencyFormula(new RDLSpecDependency(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getPrimedResource(), dependedInsideList) ,dependedOutsideList))); - }else{ - spec.addRDLSpecStatement(new RDLSpecDependencyFormula(new RDLSpecDependency(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedInsideList) ,dependedOutsideList))); - } - - } -} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/GenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/GenerateRDL.java deleted file mode 100644 index d12d602..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/GenerateRDL.java +++ /dev/null @@ -1,66 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; -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.io.BufferedReader; -import java.util.Map; - -public class GenerateRDL { - - //screenのJsonとtableのJsonをまとめてreturnする用 - private record SeparatedJsonValue(Value screen, Value table){} - - RDLSpec spec = new RDLSpec(); - - public GenerateRDL() { - Parser parser = new Parser(); - MetaScreenGenerateRDL metaScreenGenerateRDL = new MetaScreenGenerateRDL(spec); - MetaTableGenerateRDL metaTableGenerateRDL = new MetaTableGenerateRDL(spec); - MetaScreenViewGenerateRDL metaScreenViewGenerateRDL = new MetaScreenViewGenerateRDL(spec); - ScreenGenerateRDL screenGenerateRDL = new ScreenGenerateRDL(parser.getValue(), spec); - - System.out.println(spec.toString()); - } - - public GenerateRDL(final BufferedReader reader) { - Parser parser = new Parser(reader); - - //メタアプリケーション仕様 - MetaScreenGenerateRDL metaScreenGenerateRDL = new MetaScreenGenerateRDL(spec); - MetaTableGenerateRDL metaTableGenerateRDL = new MetaTableGenerateRDL(spec); - MetaScreenViewGenerateRDL metaScreenViewGenerateRDL = new MetaScreenViewGenerateRDL(spec); - - //JsonをScreen部分とTable部分に分割 - SeparatedJsonValue separatedJson = separateJsonValue(parser.getValue()); - - //アプリケーション固有仕様 - ScreenGenerateRDL screenGenerateRDL = new ScreenGenerateRDL(separatedJson.screen, spec); - TableGenerateRDL tableGenerateRDL = new TableGenerateRDL(separatedJson.table, spec); - - System.out.println(spec.toString()); - spec.outputConstant(); //デバッグ用 - } - - //一つのJsonValueからScreenとTableにそれぞれValueを分割 - private SeparatedJsonValue separateJsonValue(Value parserValue) { - Map jsonmap = ((JsonValue) parserValue).getJson(); - - Value screenValue = null; - Value tableValue = null; - - for (StringValue key : jsonmap.keySet()) { - if (key.getStringValue().equals("screen")) { - screenValue = jsonmap.get(key); - } else if (key.getStringValue().equals("table")) { - tableValue = jsonmap.get(key); - } - } - - return new SeparatedJsonValue(screenValue, tableValue); - } -} - 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/MetaScreenRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenRDLGenerator.java deleted file mode 100644 index 30077e9..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenRDLGenerator.java +++ /dev/null @@ -1,52 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -import java.util.ArrayList; -import java.util.List; - - -public class MetaScreenRDLGenerator extends RDLGeneratorBase { - - ArrayList metaIdList = new ArrayList<>(List.of("wText", "wType", "wState", "wX", "wY", "wWidth", "wHeight", "wEnabled", "wVisible", "wColor")); - - public MetaScreenRDLGenerator() { - 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(createElementPairDependency("screen", "scId", false)); - addDependencyFormula(createElementPairDependency("screen", "scId", true)); - for (String mId : metaIdList) { - addDependencyFormula(createElementPairDependency(mId, "widget", false)); - } - - // [widget:wid]:screen - addDependencyFormula(createNestedDependency("widget", "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/MetaScreenViewRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewRDLGenerator.java deleted file mode 100644 index 4a474c4..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewRDLGenerator.java +++ /dev/null @@ -1,53 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -import java.util.List; - -public class MetaScreenViewRDLGenerator extends RDLGeneratorBase { - - public MetaScreenViewRDLGenerator() { - 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(createElementPairDependency("curWidget", "curWId", false)); - addDependencyFormula(createElementPairDependency("curWidget", "curWId", true)); - addDependencyFormula(createElementPairDependency("curWText", "curWidget", false)); - addDependencyFormula(createElementPairDependency("curWState", "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 = createDependencyTermFromList("widget", 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(spec.getRDLSpecResourceDeclaration("curWidget").getResource(), 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/MetaTableRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTableRDLGenerator.java deleted file mode 100644 index 7976bd4..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTableRDLGenerator.java +++ /dev/null @@ -1,38 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -public class MetaTableRDLGenerator extends RDLGeneratorBase { - - public MetaTableRDLGenerator() { - 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(createElementPairDependency("table", "tableId", false)); - addDependencyFormula(createElementPairDependency("table", "tableId", true)); - addDependencyFormula(createElementPairDependency("keyName", "table", false)); - - addDependencyFormula(createNestedDependency("columnName", "columnNo", false, "table", false)); - addDependencyFormula(createNestedDependency("columnValue", "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 index 45da2d3..5665b5a 100644 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGenerator.java +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGenerator.java @@ -13,16 +13,16 @@ final StringValue VALUE_KEY_TABLE = new StringValue("table"); public RDLGenerator(final BufferedReader reader) { - RDLGeneratorBase.resetSpec(); + GeneratorBase.resetSpec(); generateMetaAppRDL(); generateUniqueAppRDL(reader); } //メタアプリケーション仕様 private void generateMetaAppRDL() { - MetaScreenRDLGenerator metaScreenRDLGenerator = new MetaScreenRDLGenerator(); - MetaTableRDLGenerator metaTableRDLGenerator = new MetaTableRDLGenerator(); - MetaScreenViewRDLGenerator metaScreenViewRDLGenerator = new MetaScreenViewRDLGenerator(); + MetaScreen metaScreen = new MetaScreen(); + MetaTable metaTable = new MetaTable(); + MetaScreenView metaScreenView = new MetaScreenView(); } //アプリケーション固有仕様 @@ -31,12 +31,14 @@ //JsonValueを取得 JsonValue jsonValue = parser.parseJsonValue(); - ScreenRDLGenerator screenRDLGenerator = new ScreenRDLGenerator((JsonValue) jsonValue.getValue(VALUE_KEY_SCREEN)); - TableRDLGenerator tableRDLGenerator = new TableRDLGenerator((JsonValue) jsonValue.getValue(VALUE_KEY_TABLE)); + AppUniqueScreen appUniqueScreen = new AppUniqueScreen((JsonValue) jsonValue.getValue(VALUE_KEY_SCREEN)); + AppUniqueTable appUniqueTable = new AppUniqueTable((JsonValue) jsonValue.getValue(VALUE_KEY_TABLE)); + AppUniqueInitialValue appUniqueInitialValue = new AppUniqueInitialValue(); + AppUniqueEventHandler appUniqueEventHandler = new AppUniqueEventHandler(); } public RDLSpec getSpec() { - return RDLGeneratorBase.getSpec(); + return GeneratorBase.getSpec(); } } diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGeneratorBase.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGeneratorBase.java deleted file mode 100644 index 2968f7e..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGeneratorBase.java +++ /dev/null @@ -1,228 +0,0 @@ -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 RDLGeneratorBase { - - static protected RDLSpec spec; - - public RDLGeneratorBase() { - } - - //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; - } - - //RDL式を作成するためのList(dependedはListで渡す必要があるため) - public List createDependedResourceList(String depended, boolean dependedPrime) { - List dependedResourceList = new ArrayList<>(); - - if (dependedPrime) { - dependedResourceList.add(spec.getRDLSpecResourceDeclaration(depended).getPrimedResource()); - } else { - dependedResourceList.add(spec.getRDLSpecResourceDeclaration(depended).getResource()); - } - - return dependedResourceList; - } - - //RDL式を作成するためのList(dependedはListで渡す必要があるため) - public List createDependedResourcesList(String depended01, boolean dependedPrime01, String depended02, boolean dependedPrime02) { - List dependedResourcesList = new ArrayList<>(); - - if (dependedPrime01) { - dependedResourcesList.add(spec.getRDLSpecResourceDeclaration(depended01).getPrimedResource()); - } else { - dependedResourcesList.add(spec.getRDLSpecResourceDeclaration(depended01).getResource()); - } - - if (dependedPrime02) { - dependedResourcesList.add(spec.getRDLSpecResourceDeclaration(depended02).getPrimedResource()); - } else { - dependedResourcesList.add(spec.getRDLSpecResourceDeclaration(depended02).getResource()); - } - return dependedResourcesList; - } - - // DependencyTerm用のArgumentリスト - public List createArgumentList(String argument, String dependedId) { - List argumentList = new ArrayList<>(); - argumentList.add(spec.getConstant(argument, spec.getRDLSpecResourceDeclaration(dependedId).getResource().getValueType())); - - return argumentList; - } - - public List createArgumentsList(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; - } - - // 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)); - } - - // depending : depended - public RDLSpecDependency createElementPairDependency(String depending, String depended, boolean dependedId) { - List dependedList = createDependedResourceList(depended, dependedId); - return new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedList); - } - - // depending : dependedList - public RDLSpecDependency createElementPairDependency(String depending, List dependedList) { - return new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedList); - } - - - // [depending : insideDepended]:outsideDepended - public RDLSpecDependency createNestedDependency(String depending, String insideDepended, boolean insideDependedPrime, String outsideDepended, boolean outsideDependedPrime) { - RDLSpecDependency nestedDependency; - List insideDependedList = createDependedResourceList(insideDepended, insideDependedPrime); - List outsideDependedList = createDependedResourceList(outsideDepended, outsideDependedPrime); - - nestedDependency = new RDLSpecDependency(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), insideDependedList), outsideDependedList); - - return nestedDependency; - - } - - // [depending : depended01, depended02] : outsideDepended - public RDLSpecDependency createNestedDependency(String depending, String depended01, boolean depended01Primed, String depended02, boolean depended02Primed, String outsideDepended, boolean outsideDependedPrimed) { - RDLSpecDependency nestedDependency; - List insideDependedList = createDependedResourcesList(depended01, depended01Primed, depended02, depended02Primed); - List outsideDependedList = createDependedResourceList(outsideDepended, outsideDependedPrimed); - - nestedDependency = new RDLSpecDependency(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), insideDependedList), outsideDependedList); - - return nestedDependency; - } - - // [depending : insideDependedList] : outsideDependedList - public RDLSpecDependency createNestedDependencyFromList(String depending, List insideDependedList, List outsideDependedList) { - RDLSpecDependency nestedDependency; - - nestedDependency = new RDLSpecDependency(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), insideDependedList), outsideDependedList); - - return nestedDependency; - } - - // [depending : depended -> argument] - public RDLSpecDependencyTerm createDependencyTerm(String depending, String depended, boolean dependedPrime, String argument) { - RDLSpecDependencyTerm dependencyTerm; - List dependedList = createDependedResourceList(depended, dependedPrime); - List arguemntList = createArgumentList(argument, depended); - dependencyTerm = new RDLSpecDependencyTerm(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedList, arguemntList); - - return dependencyTerm; - } - - // [depending : depended01 -> argument01, depended02 -> argument02] - public RDLSpecDependencyTerm createDependencyTerm(String depending, String depended01, boolean dependedPrime01, String argument01, String depended02, boolean dependedPrime02, String argument02) { - RDLSpecDependencyTerm dependencyTerm; - List dependedList = createDependedResourcesList(depended01, dependedPrime01, depended02, dependedPrime02); - List argumentList = createArgumentsList(argument01, depended01, argument02, depended02); - dependencyTerm = new RDLSpecDependencyTerm(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedList, argumentList); - - return dependencyTerm; - } - - // [depending : dependedList -> argumentList] - public RDLSpecDependencyTerm createDependencyTermFromList(String depending, List depenededList, List argumentList) { - RDLSpecDependencyTerm dependencyTerm; - dependencyTerm = new RDLSpecDependencyTerm(spec.getRDLSpecResourceDeclaration(depending).getResource(), depenededList, argumentList); - return dependencyTerm; - } - - // [(dependencyTerm) : depended -> argument] - public RDLSpecDependencyTerm createNestedDependencyTermFromTerm(RDLSpecEvaluatableTerm dependingTerm, String depended, boolean dependedPrime, String argument) { - RDLSpecDependencyTerm dependencyTerm; - List dependedList = createDependedResourceList(depended, dependedPrime); - List argumentList = createArgumentList(argument, depended); - dependencyTerm = new RDLSpecDependencyTerm(dependingTerm, dependedList, argumentList); - - return dependencyTerm; - } - - // [(dependencyTerm) : dependedList -> argumentList] - public RDLSpecDependencyTerm createNestedDependencyTermFromTerm(RDLSpecEvaluatableTerm dependingTerm, List depenededList, List argumentList) { - RDLSpecDependencyTerm dependencyTerm; - dependencyTerm = new RDLSpecDependencyTerm(dependingTerm, depenededList, argumentList); - - return dependencyTerm; - } - - public RDLSpecDependencyTerm createNestedDependencyTermFromTerm(RDLSpecEvaluatableTerm dependingTerm, String depended01, boolean dependedPrime01, String argument01, String depended02, boolean dependedPrime02, String argument02) { - RDLSpecDependencyTerm dependencyTerm; - List dependedList = createDependedResourcesList(depended01, dependedPrime01, depended02, dependedPrime02); - List argumentList = createArgumentsList(argument01, depended01, argument02, depended02); - dependencyTerm = new RDLSpecDependencyTerm(dependingTerm, dependedList, argumentList); - - return dependencyTerm; - } - - - // [depending: insideDependedId -> insideArguments] : outsideDependedId -> outsideArguments] - public RDLSpecDependencyTerm createNestedDependencyTerm(String depending, String insideDependedId, boolean insideDependedIdPrime, String insideArgument, String outsideDependedId, boolean outsideDependedIdPrime, String outsideArgument) { - - RDLSpecDependencyTerm insideDependencyTerm = createDependencyTerm(depending, insideDependedId, insideDependedIdPrime, insideArgument); - List outsideDependedResourceList = createDependedResourceList(outsideDependedId, outsideDependedIdPrime); - List outsideArgumentsList = createArgumentList(outsideArgument, outsideDependedId); - - return new RDLSpecDependencyTerm(insideDependencyTerm, outsideDependedResourceList, outsideArgumentsList); - } - - - // 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); - } - - public void addInitializationFormula(RDLSpecInitialization rdlInitializationFormula) { - - spec.addRDLSpecStatement(rdlInitializationFormula); - } - - -} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenRDLGenerator.java deleted file mode 100644 index 768e22b..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenRDLGenerator.java +++ /dev/null @@ -1,53 +0,0 @@ -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 ScreenRDLGenerator extends RDLGeneratorBase { - - // parser済みのJsonを引数とする - public ScreenRDLGenerator(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, "wId", false, wIdString, "scId", false, scIdString, data)); - } - } - } - } - - - //ex [[wText : wId -> "editBotton"] : scId -> "一覧画面"] := "編集" - private RDLSpecInitialization createScreenInitialization(String depending, String insideDependedId, boolean insideDependedIdPrime, String insideArgument, String outsideDependedId, boolean outsideDependedIdPrime, String outsideArguments, Value initializeValue) { - - RDLSpecInitialization initialization; - RDLSpecDependencyTerm left = createNestedDependencyTerm(depending, insideDependedId, insideDependedIdPrime, insideArgument, outsideDependedId, outsideDependedIdPrime, outsideArguments); - initialization = new RDLSpecInitialization(left, spec.getConstant(initializeValue.toString(), checkValueType(initializeValue))); - - return initialization; - } -} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/TableRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/TableRDLGenerator.java deleted file mode 100644 index da0757d..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/TableRDLGenerator.java +++ /dev/null @@ -1,71 +0,0 @@ -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 TableRDLGenerator extends RDLGeneratorBase { - - public TableRDLGenerator(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(createTableDependencyEquationFormula(metaIdString, "tableId", false, 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(createNestedDependencyEquationFormula(metaIdString, "columnNo", false, Integer.toString(index), "tableId", false, tableNameString, v)); - } - index++; - } - } - } - } - } - - } - - //[depending : dependedId -> arguments] = value , ex [keyName : tableId -> "顧客"] = "顧客ID" - public RDLSpecEquationFormula createTableDependencyEquationFormula(String depending, String dependedId, boolean dependedIdPrime, String argument, Value corrValue) { - RDLSpecEquationFormula equationFormula; - RDLSpecDependencyTerm dependencyTerm = createDependencyTerm(depending, dependedId, dependedIdPrime, argument); - - equationFormula = new RDLSpecEquationFormula(dependencyTerm, spec.getConstant(corrValue.toString(), checkValueType(corrValue))); - - return equationFormula; - } - - //[depending: insideDependedId -> insideArguments] : outsideDependedId -> outsideArguments] = corrValue - public RDLSpecEquationFormula createNestedDependencyEquationFormula(String depending, String insideDependedId, boolean insideDependedIdPrime, String insideArgument, String outsideDependedId, boolean outsideDependedIdPrime, String outsideArgument, Value corrValue) { - RDLSpecEquationFormula equationFormula; - RDLSpecDependencyTerm nestedDependencyTerm = createNestedDependencyTerm(depending, insideDependedId, insideDependedIdPrime, insideArgument, outsideDependedId, outsideDependedIdPrime, outsideArgument); - - equationFormula = new RDLSpecEquationFormula(nestedDependencyTerm, spec.getConstant(corrValue.toString(), checkValueType(corrValue))); - - return equationFormula; - - } -} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java index 7ff1ad9..1f71897 100644 --- a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java @@ -91,20 +91,4 @@ } return sb.toString(); } - - public void outputResource(){ - StringBuilder sb = new StringBuilder(); - for (String key :resourceMap.keySet()){ - sb.append(getRDLSpecResourceDeclaration(key)).append("\n"); - } - System.out.println(sb); - } - - public void outputConstant(){ - StringBuilder sb = new StringBuilder(); - for (String key : rdlSpecResourceConstantMap.keySet()) { - sb.append(key).append(", ").append("primitive, ").append("\n"); - } - System.out.println(sb); - } }