diff --git a/src/main/java/org/ntlab/rdlcanvas/Main.java b/src/main/java/org/ntlab/rdlcanvas/Main.java index 0330b5b..2ab9946 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-wighet-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/MetaScreenGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenGenerateRDL.java deleted file mode 100644 index 2a24c22..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenGenerateRDL.java +++ /dev/null @@ -1,54 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -import java.util.ArrayList; -import java.util.List; - - -public class MetaScreenGenerateRDL extends BaseMetaGenerateRDL { - - ArrayList metaIdList = new ArrayList<>(List.of("wText", "wType", "wState", "wX", "wY", "wWidth", "wHeight", "wEnabled", "wVisible", "wColor")); - - public MetaScreenGenerateRDL(RDLSpec spec){ - addScreenTemplateResourceDeclaration(spec); - addScreenTemplateFormula(spec); - //System.out.println(spec.toString()); //デバッグ用 - } - - private void addScreenTemplateResourceDeclaration(RDLSpec spec){ - - //ex screen(1) :: struct - addResourceDeclaration(spec, "screen", 1, StructuralType.structure, null); - addResourceDeclaration(spec, "scId", 1, StructuralType.id, RDLSpecLang.typeString); - addResourceDeclaration(spec, "widget", 2, StructuralType.structure, null); - addResourceDeclaration(spec, "wId", 2, StructuralType.id, RDLSpecLang.typeString); - addResourceDeclaration(spec, "wText", 2, RDLSpecLang.typeString); - addResourceDeclaration(spec, "wType", 2, RDLSpecLang.typeString); - addResourceDeclaration(spec, "wState", 2, RDLSpecLang.typeString); - addResourceDeclaration(spec, "wX", 2, RDLSpecLang.typeInt); - addResourceDeclaration(spec, "wY", 2, RDLSpecLang.typeInt); - addResourceDeclaration(spec, "wWidth", 2, RDLSpecLang.typeInt); - addResourceDeclaration(spec, "wHeight", 2, RDLSpecLang.typeInt); - addResourceDeclaration(spec, "wEnabled", 2, RDLSpecLang.typeBoolean); - addResourceDeclaration(spec, "wVisible", 2, RDLSpecLang.typeBoolean); - addResourceDeclaration(spec, "wColor", 2, RDLSpecLang.typeString); - } - - private void addScreenTemplateFormula(RDLSpec spec){ - - //ex screen:scId - addElementPairDependencyFormula(spec, "screen", false, "scId", false); - addElementPairDependencyFormula(spec, "screen", false, "scId", true); - for(String mId : metaIdList){ - addElementPairDependencyFormula(spec, mId,false, "widget", false); - } - - // [widget:wid]:screen - addNestedDependencyFormula(spec, "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 new file mode 100644 index 0000000..30077e9 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenRDLGenerator.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 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/MetaScreenViewGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewGenerateRDL.java deleted file mode 100644 index 3d697cd..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewGenerateRDL.java +++ /dev/null @@ -1,48 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -import java.util.ArrayList; -import java.util.Arrays; - -public class MetaScreenViewGenerateRDL extends BaseMetaGenerateRDL{ - - public MetaScreenViewGenerateRDL(RDLSpec spec){ - addScreenViewResourceDeclaration(spec); - addScreenViewFormula(spec); - } - - private void addScreenViewResourceDeclaration(RDLSpec spec){ - - // ex curWidget(1)::struct - addResourceDeclaration(spec, "curWidget", 1, StructuralType.structure, null); - addResourceDeclaration(spec, "curWId", 1, StructuralType.id, RDLSpecLang.typeString); - addResourceDeclaration(spec, "curWText", 1, RDLSpecLang.typeString); - addResourceDeclaration(spec, "curWState", 1, RDLSpecLang.typeString); - addResourceDeclaration(spec, "curScId", 0, StructuralType.id, RDLSpecLang.typeString); - - } - - private void addScreenViewFormula(RDLSpec spec){ - - // ex curWidget:curWId - addElementPairDependencyFormula(spec, "curWidget", false, "curWId", false); - addElementPairDependencyFormula(spec, "curWidget", false, "curWId", true); - addElementPairDependencyFormula(spec, "curWText", false, "curWidget", false); - addElementPairDependencyFormula(spec, "curWState", false, "curWidget", false); - - - addScreenViewEquationFormula(spec); - - } - - // curWidget = [[widget:wId->curWId]:scId->curScId, curWId->curWId] - private void addScreenViewEquationFormula(RDLSpec spec){ - RDLSpecDependencyTerm insideDependencyTerm = new RDLSpecDependencyTerm(spec.getRDLSpecResourceDeclaration("widget").getResource(), new ArrayList<>(Arrays.asList(spec.getRDLSpecResourceDeclaration("wId").getResource())), new ArrayList<>(Arrays.asList(spec.getRDLSpecResourceDeclaration("curWId").getResource()))); - RDLSpecDependencyTerm outsideDependencyTerm = new RDLSpecDependencyTerm(insideDependencyTerm, new ArrayList<>(Arrays.asList(spec.getRDLSpecResourceDeclaration("scId").getResource(), spec.getRDLSpecResourceDeclaration("curWId").getResource())), new ArrayList<>(Arrays.asList(spec.getRDLSpecResourceDeclaration("curScId").getResource(), spec.getRDLSpecResourceDeclaration("curWId").getResource()))); - RDLSpecEquationFormula rdlSpecEquationFormula = new RDLSpecEquationFormula(spec.getRDLSpecResourceDeclaration("curWidget").getResource(), outsideDependencyTerm); - spec.addRDLSpecStatement(rdlSpecEquationFormula); - - } - -} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewRDLGenerator.java new file mode 100644 index 0000000..ee0a65e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaScreenViewRDLGenerator.java @@ -0,0 +1,53 @@ +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/MetaTableGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTableGenerateRDL.java deleted file mode 100644 index 160b063..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTableGenerateRDL.java +++ /dev/null @@ -1,70 +0,0 @@ -package org.ntlab.rdlcanvas.generaterdl; - -import org.ntlab.rdlcanvas.models.*; - -import java.util.ArrayList; -import java.util.List; - -public class MetaTableGenerateRDL extends BaseMetaGenerateRDL{ - - public MetaTableGenerateRDL(RDLSpec spec){ - addMetaTableResourceDeclaration(spec); - addMetaTableFormula(spec); - } - - private void addMetaTableResourceDeclaration(RDLSpec spec){ - - // ex table(1)::structure - addResourceDeclaration(spec, "table", 1, StructuralType.structure, null); - addResourceDeclaration(spec, "tableId", 1, StructuralType.id, RDLSpecLang.typeString); - addResourceDeclaration(spec, "keyName", 1, RDLSpecLang.typeString); - addResourceDeclaration(spec, "curKey", 1, RDLSpecLang.typeString); - addResourceDeclaration(spec, "columnName", 2, RDLSpecLang.typeString); - addResourceDeclaration(spec, "columnNo", 2, StructuralType.id, RDLSpecLang.typeInt); - addResourceDeclaration(spec, "columnValue", 2, RDLSpecLang.typeString); - addResourceDeclaration(spec, "key", 2, StructuralType.id, RDLSpecLang.typeString); - - } - - private void addMetaTableFormula(RDLSpec spec){ - - // ex table:tableId - addElementPairDependencyFormula(spec, "table", false, "tableId", false); - addElementPairDependencyFormula(spec, "table", false, "tableId", true); - addElementPairDependencyFormula(spec, "keyName", false, "table", false); - - addNestedDependencyFormula(spec, "columnName", false, "columnNo", false, "table", false); - addNestedDependencyFormula(spec, "columnValue", false, "columnNo", false, "key", false, "table", false); - } - - - // [depending:depended01, depended02]:outsideDepended - public void addNestedDependencyFormula(RDLSpec spec, String depending, boolean dependingPrimed, String depended01, boolean depended01Primed, String depended02, boolean depended02Primed, String outsideDepended, boolean outsideDependedPrimed) { - List dependedInsideList = new ArrayList<>(); - List dependedOutsideList = new ArrayList<>(); - - if(depended01Primed){ - dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended01).getPrimedResource()); - }else{ - dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended01).getResource()); - } - - if(depended02Primed){ - dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended02).getPrimedResource()); - }else{ - dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended02).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/MetaTableRDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTableRDLGenerator.java new file mode 100644 index 0000000..7976bd4 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/MetaTableRDLGenerator.java @@ -0,0 +1,38 @@ +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 new file mode 100644 index 0000000..26900ce --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGenerator.java @@ -0,0 +1,45 @@ +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){ + RDLGeneratorBase.resetSpec(); + generateMetaAppRDL(); + generateUniqueAppRDL(reader); + } + + //メタアプリケーション仕様 + private void generateMetaAppRDL(){ + MetaScreenRDLGenerator metaScreenRDLGenerator = new MetaScreenRDLGenerator(); + MetaTableRDLGenerator metaTableRDLGenerator =new MetaTableRDLGenerator(); + MetaScreenViewRDLGenerator metaScreenViewRDLGenerator = new MetaScreenViewRDLGenerator(); + } + + //アプリケーション固有仕様 + private void generateUniqueAppRDL(BufferedReader reader){ + Parser parser = new Parser(reader); + + + //JsonをScreen部分とTable部分に分割 + //JsonValue jsonValue = parser.parseJsonValue(); + + +// ScreenGenerateRDL screenGenerateRDL = new ScreenGenerateRDL(jsonValue.getValue(STRING_VALUE_SCREEN), spec); +// TableGenerateRDL tableGenerateRDL = new TableGenerateRDL(separatedJson.table, spec); + + } + + public RDLSpec getSpec(){ + return RDLGeneratorBase.getSpec(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGeneratorBase.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGeneratorBase.java new file mode 100644 index 0000000..1e110b7 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/RDLGeneratorBase.java @@ -0,0 +1,223 @@ +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); + } + + +}