diff --git a/models/screen-wighet-sample.json b/models/screen-wighet-sample.json new file mode 100644 index 0000000..cc87bf4 --- /dev/null +++ b/models/screen-wighet-sample.json @@ -0,0 +1,42 @@ +{ + "一覧画面": { + "editButton": { + "wType": "button", + "wText": "編集", + "wX": 100, + "wY": 100, + "wWidth": 50, + "wHeight": 20, + "enable": true, + "wColor": "blue" + }, + "customerTable":{ + "wType": "table", + "wX": 100, + "wY": 200, + "wWidth": 1200, + "wHeight": 800, + "wEnable": true + } + }, + "編集画面": { + "nameInput": { + "wType": "textInput", + "wText": "", + "wX": 100, + "wY": 100, + "wWidth": 100, + "wHeight": 20 + }, + "updateButton": { + "wType": "button", + "wText": "更新", + "wX": 300, + "wY": 300, + "wWidth": 50, + "wHeight": 20, + "wEnable": true, + "wColor": "blue" + } + } +} \ No newline at end of file diff --git a/src/main/java/org/ntlab/rdlcanvas/Main.java b/src/main/java/org/ntlab/rdlcanvas/Main.java index a5bddc1..1fb6bb8 100644 --- a/src/main/java/org/ntlab/rdlcanvas/Main.java +++ b/src/main/java/org/ntlab/rdlcanvas/Main.java @@ -1,22 +1,23 @@ 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 org.ntlab.rdlcanvas.generaterdl.GenerateRDL; -import java.util.Map; +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()); -// Map map = ((JsonValue)value).getJson(); -// for (StringValue key : map.keySet()){ -// String keyName = key.getStringValue(); -// System.out.println(keyName); -// } + File file = new File("models/screen-wighet-sample.json"); + try{ + BufferedReader reader = new BufferedReader(new FileReader(file)); + GenerateRDL generateRDL = new GenerateRDL(reader); + } catch(FileNotFoundException e) { + e.printStackTrace(); + } + } } diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/GenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/GenerateRDL.java new file mode 100644 index 0000000..9443429 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/GenerateRDL.java @@ -0,0 +1,28 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.RDLSpec; +import org.ntlab.rdlcanvas.parser.Parser; + +import java.io.BufferedReader; + +public class GenerateRDL { + + RDLSpec spec = new RDLSpec(); + + public GenerateRDL() { + Parser parser = new Parser(); + ScreenTemplateGenerateRDL screenTemplateGenerateRDL = new ScreenTemplateGenerateRDL(spec); + ScreenGenerateRDL screenGenerateRDL = new ScreenGenerateRDL(parser.getValue(), spec); + System.out.println(spec.toString()); + spec.outputConstant(); + } + + public GenerateRDL(final BufferedReader reader) { + Parser parser = new Parser(reader); + ScreenTemplateGenerateRDL screenTemplateGenerateRDL = new ScreenTemplateGenerateRDL(spec); + ScreenGenerateRDL screenGenerateRDL = new ScreenGenerateRDL(parser.getValue(), spec); + System.out.println(spec.toString()); + spec.outputConstant(); + } +} + diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenGenerateRDL.java new file mode 100644 index 0000000..66c6d0e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenGenerateRDL.java @@ -0,0 +1,66 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; +import org.ntlab.rdlcanvas.parser.StringValue; +import org.ntlab.rdlcanvas.parser.Value; + +import java.util.*; + +public class ScreenGenerateRDL{ + + //-> RDLSpecStatementのリストにすべて入れる + + + // parser済みのJsonを引数とする + public ScreenGenerateRDL(Value value, RDLSpec spec){ + createScreenConstant(value, spec); + } + + // Jsonを構成するデータを抽出する + private void createScreenConstant(Value value, RDLSpec spec){ + + Map screenmap = ((org.ntlab.rdlcanvas.parser.JsonValue)value).getJson(); + + for (StringValue key1 : screenmap.keySet()){ + String scIdString = key1.getStringValue(); //ScreenIDをStringValue(key1)からStringに変換 + spec.getConstant(scIdString, checkValueType(key1)); //定数(Constant)の一覧に値を登録 + Value widgets = screenmap.get(key1); + Map widgetmap = ((org.ntlab.rdlcanvas.parser.JsonValue)widgets).getJson(); + + for (StringValue key2 : widgetmap.keySet()){ + String wIdString = key2.getStringValue(); //widgetIDをStringValue(key2)からStringに変換 + spec.getConstant(wIdString, checkValueType(key2)); + Value metas = widgetmap.get(key2); + Map metamap = ((org.ntlab.rdlcanvas.parser.JsonValue)metas).getJson(); + + for (StringValue key3 : metamap.keySet()){ + String metaIdString = key3.getStringValue(); //MetaIDをStringValue(key3)からStringへ変換 + Value data = metamap.get(key3); //Dataを取得 + String dataString = data.toString(); + spec.getConstant(dataString, checkValueType(data)); + createScreenDefinition(scIdString, wIdString, metaIdString, dataString, spec); + } + } + } + //spec.outputConstant(); //デバッグ用 Constantを出力 + } + + + private 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; + } + + //ただし定数はどうStatementに持ってくるか + private void createScreenDefinition(String scIdName, String wIdName, String metaIdName, String dataName, RDLSpec spec){ + RDLSpecDependencyTerm insideDependencyTerm = new RDLSpecDependencyTerm(spec.getConstant(metaIdName, RDLSpecLang.typeString), new ArrayList<>(Arrays.asList(spec.getRDLSpecResourceDeclaration("wId").getResource())), new ArrayList<>(Arrays.asList(spec.getConstant(wIdName, RDLSpecLang.typeString)))); + RDLSpecDependencyTerm outsideDependencyTerm = new RDLSpecDependencyTerm(insideDependencyTerm, new ArrayList<>(Arrays.asList(spec.getRDLSpecResourceDeclaration("scId").getResource())), new ArrayList<>(Arrays.asList(spec.getConstant(scIdName, RDLSpecLang.typeString)))); + spec.addRDLSpecStatement(new RDLSpecInitialization(outsideDependencyTerm, spec.getConstant(dataName, RDLSpecLang.typeString))); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenTemplateGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenTemplateGenerateRDL.java new file mode 100644 index 0000000..87abc66 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenTemplateGenerateRDL.java @@ -0,0 +1,79 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import org.ntlab.rdlcanvas.models.*; + +import java.util.ArrayList; +import java.util.List; + + +public class ScreenTemplateGenerateRDL{ + + public ScreenTemplateGenerateRDL(RDLSpec spec){ + createScreenTemplateResourceDeclaration(spec); + createScreenTemplateFormula(spec); + //System.out.println(spec.toString()); //デバッグ用 + } + + private void createScreenTemplateResourceDeclaration(RDLSpec spec){ + + //ex screen(1) :: struct + spec.addRDLSpecResourceDeclaration("screen", 1, StructuralType.structure, null); + spec.addRDLSpecResourceDeclaration("scId", 1, StructuralType.id, RDLSpecLang.typeString); + spec.addRDLSpecResourceDeclaration("widget", 2, StructuralType.structure, null); + spec.addRDLSpecResourceDeclaration("wId", 2, StructuralType.id, RDLSpecLang.typeString); + spec.addRDLSpecResourceDeclaration("wText", 2, RDLSpecLang.typeString); + spec.addRDLSpecResourceDeclaration("wType", 2, RDLSpecLang.typeString); + spec.addRDLSpecResourceDeclaration("wState", 2, RDLSpecLang.typeString); + spec.addRDLSpecResourceDeclaration("wX", 2, RDLSpecLang.typeInt); + spec.addRDLSpecResourceDeclaration("wY", 2, RDLSpecLang.typeInt); + spec.addRDLSpecResourceDeclaration("wWidth", 2, RDLSpecLang.typeInt); + spec.addRDLSpecResourceDeclaration("wHeight", 2, RDLSpecLang.typeInt); + spec.addRDLSpecResourceDeclaration("wEnabled", 2, RDLSpecLang.typeBoolean); + spec.addRDLSpecResourceDeclaration("wVisible", 2, RDLSpecLang.typeBoolean); + spec.addRDLSpecResourceDeclaration("wColor", 2, RDLSpecLang.typeString); + + //SpecStatementにResourceDeclaretionを追加 + for(String name: spec.getResourceMap().keySet()){ + spec.addRDLSpecStatement(spec.getRDLSpecResourceDeclaration(name)); + } + } + + private void createScreenTemplateFormula(RDLSpec spec){ + + //ex screen:scId + createElementPairDependencyFormula("scId", "screen", spec); + createElementPairDependencyFormula("wText", "widget", spec); + createElementPairDependencyFormula("wType", "widget", spec); + createElementPairDependencyFormula("wState", "widget", spec); + createElementPairDependencyFormula("wX", "widget", spec); + createElementPairDependencyFormula("wY", "widget", spec); + createElementPairDependencyFormula("wHeight", "widget", spec); + createElementPairDependencyFormula("wWidth", "widget", spec); + createElementPairDependencyFormula("wEnabled", "widget", spec); + createElementPairDependencyFormula("wVisible", "widget", spec); + createElementPairDependencyFormula("wColor", "widget", spec); + + // [widget:wid]:screen + createNestedDependencyFormula("widget", "wId", "screen", spec); + + } + + private void createElementPairDependencyFormula(String depending, String depended, RDLSpec spec){ + + List dependedList = new ArrayList<>(); + dependedList.add(spec.getRDLSpecResourceDeclaration(depended).getResource()); + spec.addRDLSpecStatement(new RDLSpecDependencyFormula(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedList))); + + } + + private void createNestedDependencyFormula(String depending, String depended, String outsideDepended ,RDLSpec spec){ + List dependedInsideList = new ArrayList<>(); + List dependedOutsideList = new ArrayList<>(); + dependedInsideList.add(spec.getRDLSpecResourceDeclaration(depended).getResource()); + dependedOutsideList.add(spec.getRDLSpecResourceDeclaration(outsideDepended).getResource()); + spec.addRDLSpecStatement(new RDLSpecDependencyFormula(new RDLSpecDependency(new RDLSpecDependency(spec.getRDLSpecResourceDeclaration(depending).getResource(), dependedInsideList) ,dependedOutsideList))); + + } + + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/generaterdl/TableGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/TableGenerateRDL.java new file mode 100644 index 0000000..e0cf2cd --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/TableGenerateRDL.java @@ -0,0 +1,7 @@ +package org.ntlab.rdlcanvas.generaterdl; + +import java.util.List; + +public class TableGenerateRDL { + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java new file mode 100644 index 0000000..7ff1ad9 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java @@ -0,0 +1,110 @@ +package org.ntlab.rdlcanvas.models; + +import java.util.*; + +public class RDLSpec { + private Map resourceMap; + private List rdlSpecStatements; + private Map> rdlSpecResourceConstantMap; + + public RDLSpec() { + resourceMap = new HashMap<>(); + rdlSpecStatements = new ArrayList<>(); + rdlSpecResourceConstantMap = new HashMap<>(); + } + + public void addRDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, structuralType, valueType)); + } + + public void addRDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, valueType)); + } + + public RDLSpecResourceDeclaration getRDLSpecResourceDeclaration(String name) { + if (!resourceMap.containsKey(name)) { + return null; + } + return resourceMap.get(name); + } + + public RDLSpecResourceConstant getConstant(String value, ValueType valueType) { + if (rdlSpecResourceConstantMap.containsKey(value)) { + if (rdlSpecResourceConstantMap.get(value).containsKey(valueType)) { + return rdlSpecResourceConstantMap.get(value).get(valueType); + } else { + rdlSpecResourceConstantMap.get(value).put(valueType,new RDLSpecResourceConstant(value, valueType)); + } + } else { + rdlSpecResourceConstantMap.put(value, new HashMap<>()); + rdlSpecResourceConstantMap.get(value).put(valueType, new RDLSpecResourceConstant(value, valueType)); + } + return rdlSpecResourceConstantMap.get(value).get(valueType); + } + + public RDLSpecResourceConstant getTrue() { + if (!rdlSpecResourceConstantMap.containsKey("true")) { + rdlSpecResourceConstantMap.put("true", new HashMap<>()); + if (!rdlSpecResourceConstantMap.get("true").containsKey(RDLSpecLang.typeBoolean)) { + rdlSpecResourceConstantMap.get("true").put(RDLSpecLang.typeBoolean, new RDLSpecResourceConstant("true", RDLSpecLang.typeBoolean)); + } + } + return rdlSpecResourceConstantMap.get("true").get(RDLSpecLang.typeBoolean); + } + + public RDLSpecResourceConstant getFalse() { + if (!rdlSpecResourceConstantMap.containsKey("false")) { + rdlSpecResourceConstantMap.put("false", new HashMap<>()); + if (!rdlSpecResourceConstantMap.get("false").containsKey(RDLSpecLang.typeBoolean)) { + rdlSpecResourceConstantMap.get("false").put(RDLSpecLang.typeBoolean, new RDLSpecResourceConstant("false", RDLSpecLang.typeBoolean)); + } + } + return rdlSpecResourceConstantMap.get("false").get(RDLSpecLang.typeBoolean); + } + + public void addRDLSpecStatement(RDLSpecStatement rdlSpecStatement) { + rdlSpecStatements.add(rdlSpecStatement); + rdlSpecStatements.sort(Comparator.comparing(obj -> { + if (obj.isRDLSpecResourceDeclaration()) { + return 1; + } + if (obj.isRDLSpecInitialization()) { + return 2; + } + return 3; + })); + } + + public List getRDLSpecStatements() { + return rdlSpecStatements; + } + + public Map getResourceMap() { + return resourceMap; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < rdlSpecStatements.size(); i++) { + sb.append(rdlSpecStatements.get(i)).append("\n"); + } + return sb.toString(); + } + + 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); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java new file mode 100644 index 0000000..ffd3883 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java @@ -0,0 +1,19 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.Dependency; +import models.terms.EvaluatableTerm; +import models.terms.RDLTerm; + +import java.util.List; + +public class RDLSpecDependency extends Dependency { + + public RDLSpecDependency(RDLSpecDependency dependingTerm, List dependedTerms) { + super(dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + } + + public RDLSpecDependency(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms) { + super((RDLTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java new file mode 100644 index 0000000..2c63007 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java @@ -0,0 +1,20 @@ +package org.ntlab.rdlcanvas.models; + +import models.formulas.DependencyFormula; + +public class RDLSpecDependencyFormula extends DependencyFormula implements RDLSpecStatement { + + public RDLSpecDependencyFormula(RDLSpecDependency dependency) { + super(dependency); + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java new file mode 100644 index 0000000..b6e5cf0 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java @@ -0,0 +1,61 @@ +package org.ntlab.rdlcanvas.models; + +import exceptions.SyntaxException; +import models.terms.DependencyTerm; +import models.terms.EvaluatableTerm; + +import java.util.List; + +public class RDLSpecDependencyTerm extends DependencyTerm implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valuableType; + + public RDLSpecDependencyTerm(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms, List argumentTerms) { + super((EvaluatableTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList(), argumentTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + this.structuralType = ((Typable) dependingTerm).getStructuralType(); + this.valuableType = ((Typable) dependingTerm).getValueType(); + + for (int i = 0; i < dependedTerms.size(); i ++) { + if (!typeChecker(dependedTerms.get(i), argumentTerms.get(i))) { + throw new SyntaxException("the type is different"); + } + } + } + + private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); + + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { + return true; + } else { + return false; + } + } else { + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); + + if (leftValueType.equals(rightValueType)) { + return true; + } else { + return false; + } + } + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valuableType; + } + + @Override + public boolean isDependencyTerm() { + return true; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java new file mode 100644 index 0000000..a367ac1 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java @@ -0,0 +1,47 @@ +package org.ntlab.rdlcanvas.models; + +import exceptions.SyntaxException; +import models.formulas.EquationFormula; +import models.terms.EvaluatableTerm; + +public class RDLSpecEquationFormula extends EquationFormula implements RDLSpecStatement { + + public RDLSpecEquationFormula(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { + super((EvaluatableTerm) leftSideHand, (EvaluatableTerm) rightSideHand); + if (!typeChecker(leftSideHand, rightSideHand)) { + throw new SyntaxException("the type is different"); + } + } + + private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); + + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { + return true; + } else { + return false; + } + } else { + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); + + if (leftValueType.equals(rightValueType)) { + return true; + } else { + return false; + } + } + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java new file mode 100644 index 0000000..32108b9 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java @@ -0,0 +1,5 @@ +package org.ntlab.rdlcanvas.models; + +public interface RDLSpecEvaluatableTerm { + boolean isDependencyTerm(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java new file mode 100644 index 0000000..43627a2 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java @@ -0,0 +1,47 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecInitialization implements RDLSpecStatement { + RDLSpecEvaluatableTerm leftSideHand; + RDLSpecEvaluatableTerm rightSideHand; + + public RDLSpecInitialization(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { + this.leftSideHand = leftSideHand; + this.rightSideHand = rightSideHand; + } + + public RDLSpecEvaluatableTerm getLeftSideHand() { + return leftSideHand; + } + + public RDLSpecEvaluatableTerm getRightSideHand() { + return rightSideHand; + } + + @Override + public boolean isRDLSpecInitialization() { + return true; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } + + @Override + public String toString() { + return leftSideHand + " := " + rightSideHand; + } + + @Override + public boolean equals(Object another) { + if (!(another instanceof RDLSpecInitialization anotherInitialization)) { + return false; + } + return leftSideHand.equals(anotherInitialization.getLeftSideHand()) && rightSideHand.equals(anotherInitialization.getRightSideHand()); + } + + @Override + public int hashCode() { + return toString().hashCode(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java new file mode 100644 index 0000000..ba6ff86 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java @@ -0,0 +1,8 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecLang { + public static final ValueType typeString = new ValueType("string"); + public static final ValueType typeInt = new ValueType("int"); + public static final ValueType typeBoolean = new ValueType("boolean"); + public static final ValueType typeDouble = new ValueType("double"); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java new file mode 100644 index 0000000..9401c33 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java @@ -0,0 +1,49 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.Resource; + +public class RDLSpecResource extends Resource implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valueType; + + public RDLSpecResource(String name, int order, StructuralType structuralType, ValueType valueType) { + super(name, order); + if (!(structuralType == StructuralType.structure || structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.map || structuralType == StructuralType.value)) { + throw new IllegalArgumentException(structuralType + " is not expected structural type."); + } + + if (structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.value) { + if (!(valueType.equals(RDLSpecLang.typeInt) || valueType.equals(RDLSpecLang.typeDouble) || valueType.equals(RDLSpecLang.typeString) || valueType.equals(RDLSpecLang.typeBoolean))) { + throw new IllegalArgumentException(structuralType + " is not expected valuable Type."); + } + } else { + if (valueType != null) { + throw new IllegalArgumentException("It does not have a type"); + } + } + + this.structuralType = structuralType; + this.valueType = valueType; + } + + public RDLSpecResource(String name, int order, ValueType valueType) { + super(name, order); + structuralType = StructuralType.primitive; + this.valueType = valueType; + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valueType; + } + + @Override + public boolean isDependencyTerm() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java new file mode 100644 index 0000000..8050ae8 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java @@ -0,0 +1,38 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.ResourceConstant; + +public class RDLSpecResourceConstant extends ResourceConstant implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valueType; + + public RDLSpecResourceConstant(String value, ValueType valueType) { + super(value); + this.structuralType = StructuralType.primitive; + this.valueType = valueType; + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valueType; + } + + @Override + public boolean isDependencyTerm() { + return false; + } + + @Override + public String toString() { + if (valueType.getName().equals("string")) { + return "\"" + getName() + "\""; + } else { + return getName(); + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java new file mode 100644 index 0000000..eb4204e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java @@ -0,0 +1,76 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecResourceDeclaration implements RDLSpecStatement { + private RDLSpecResource resource; + private RDLSpecResource primedResource; + + public RDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + resource = new RDLSpecResource(name, order, structuralType, valueType); + if (structuralType == StructuralType.id) { + primedResource = new RDLSpecResource(name + "'", order, structuralType, valueType); + } else { + primedResource = null; + } + } + + public RDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resource = new RDLSpecResource(name, order, valueType); + primedResource = null; + } + + public RDLSpecResource getResource() { + return resource; + } + + public RDLSpecResource getPrimedResource() { + return primedResource; + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return true; + } + + @Override + public boolean equals(Object another) { + if (!(another instanceof RDLSpecResourceDeclaration rdlSpecResourceDeclaration)) { + return false; + } + + if (rdlSpecResourceDeclaration.getResource().equals(resource) && ((rdlSpecResourceDeclaration.getPrimedResource() == null && primedResource == null) || rdlSpecResourceDeclaration.getPrimedResource().equals(primedResource))) { + return true; + } else { + return false; + } + } + + @Override + public int hashCode() { + return toString().hashCode(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(resource).append("(").append(resource.getOrder()).append("):: "); + + if (resource.getStructuralType() == StructuralType.primitive) { + sb.append(resource.getValueType().getName()); + return sb.toString(); + } + + if (resource.getValueType() == null) { + sb.append(resource.getStructuralType()); + return sb.toString(); + } else { + sb.append(resource.getStructuralType()); + sb.append(", ").append(resource.getValueType().getName()); + return sb.toString(); + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java new file mode 100644 index 0000000..a2bdd1e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java @@ -0,0 +1,6 @@ +package org.ntlab.rdlcanvas.models; + +public interface RDLSpecStatement { + boolean isRDLSpecResourceDeclaration(); + boolean isRDLSpecInitialization(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java b/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java new file mode 100644 index 0000000..d4efbf7 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java @@ -0,0 +1,26 @@ +package org.ntlab.rdlcanvas.models; + +public enum StructuralType { + id, + value, + structure, + map, + primitive; + + @Override + public String toString() { + switch (this) { + case id: + return "id"; + case value: + return "value"; + case structure: + return "struct"; + case map: + return "map"; + case primitive: + default: + return ""; + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/Typable.java b/src/main/java/org/ntlab/rdlcanvas/models/Typable.java new file mode 100644 index 0000000..7b2e0ac --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/Typable.java @@ -0,0 +1,7 @@ +package org.ntlab.rdlcanvas.models; + + +public interface Typable { + StructuralType getStructuralType(); + ValueType getValueType(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java b/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java new file mode 100644 index 0000000..3939044 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java @@ -0,0 +1,21 @@ +package org.ntlab.rdlcanvas.models; + +public class ValueType { + private String name; + + public ValueType(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof ValueType)) { + return false; + } + return name.equals(((ValueType) obj).name); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/parser/BooleanValue.java b/src/main/java/org/ntlab/rdlcanvas/parser/BooleanValue.java new file mode 100644 index 0000000..10adab1 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/parser/BooleanValue.java @@ -0,0 +1,19 @@ +package org.ntlab.rdlcanvas.parser; + +public class BooleanValue extends Value{ + Boolean booleanValue; + + public void setBooleanValue(String stringValue){ + if(stringValue.equals("true")){ + booleanValue = true; + }else{ + booleanValue = false; + } + } + + @Override + public String toString(){ + return String.valueOf(booleanValue); + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java b/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java index f9e7895..b09b678 100644 --- a/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java +++ b/src/main/java/org/ntlab/rdlcanvas/parser/Parser.java @@ -24,6 +24,8 @@ public static final String COMMA = ","; public static final String COLON = ":"; public static final String DOUBLE_QUOT = "\""; + public static final String TRUE = "true"; + public static final String FALSE = "false"; // Json文字列を標準入力から受け取るコンストラクタ public Parser() { @@ -93,6 +95,8 @@ } } else if (Character.isDigit(tokenStream.checkNext().charAt(0))) { return parseIntegerValue(tokenStream); + } else if(tokenStream.checkNext().equals(TRUE) || tokenStream.checkNext().equals(FALSE)){ + return parseBooleanValue(tokenStream); } throw new RuntimeException(String.valueOf(tokenStream.getLine())); } @@ -159,6 +163,16 @@ return stringValue; } + public BooleanValue parseBooleanValue(TokenStream tokenstream){ + BooleanValue booleanValue = new BooleanValue(); + StringBuilder stringBuilder = new StringBuilder(); + while(!(stringBuilder.toString().equals(TRUE)||stringBuilder.toString().equals(FALSE))){ + stringBuilder.append(tokenstream.next()); + } + booleanValue.setBooleanValue(stringBuilder.toString()); + return booleanValue; + } + public void expect(TokenStream tokenStream, String expect) { if (!tokenStream.checkNext().equals(expect)) { throw new RuntimeException("expect" + expect + "but" + tokenStream.checkNext() + " line" + tokenStream.getLine()); diff --git a/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java b/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java index 649b82c..2afdc75 100644 --- a/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java +++ b/src/main/java/org/ntlab/rdlcanvas/parser/StringValue.java @@ -16,6 +16,6 @@ // 文字列をtoStringメゾットとして返す @Override public String toString() { - return stringValue; + return "\"" + stringValue + "\""; } } diff --git a/src/main/java/org/ntlab/rdlcanvas/rdlgenerator/RDLGenerator.java b/src/main/java/org/ntlab/rdlcanvas/rdlgenerator/RDLGenerator.java deleted file mode 100644 index c7990c7..0000000 --- a/src/main/java/org/ntlab/rdlcanvas/rdlgenerator/RDLGenerator.java +++ /dev/null @@ -1,4 +0,0 @@ -package org.ntlab.rdlcanvas.rdlgenerator; - -public class RDLGenerator { -}