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/generaterdl/ScreenGenerateRDL.java b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenGenerateRDL.java index 13e7b25..91fcf9d 100644 --- a/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenGenerateRDL.java +++ b/src/main/java/org/ntlab/rdlcanvas/generaterdl/ScreenGenerateRDL.java @@ -17,7 +17,7 @@ createData(value); createRDL(screenDataList); //outputData(); //デバッグ用 - outputRDL(); //デバッグ用 + //outputRDL(); //デバッグ用 } @@ -81,15 +81,15 @@ if(!screenDataMap.containsKey(data.toString())) { if (data.getClass().getSimpleName().equals("StringValue")) { screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("order", 2); //1階として値を登録 - screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("structureType", "value"); + screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("structuralType", "primitive"); screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("valueType", "string"); } else if (data.getClass().getSimpleName().equals("IntegerValue")) { screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("order", 2); //1階として値を登録 - screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("structureType", "value"); + screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("structuralType", "primitive"); screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("valueType", "int"); } else if (data.getClass().getSimpleName().equals("BooleanValue")) { screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("order", 2); //1階として値を登録 - screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("structureType", "value"); + screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("structuralType", "primitive"); screenDataMap.computeIfAbsent(data.toString(), k -> new HashMap<>()).put("valueType", "boolean"); } } 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..0f0239f --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpec.java @@ -0,0 +1,90 @@ +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; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < rdlSpecStatements.size(); i++) { + sb.append(rdlSpecStatements.get(i)).append("\n"); + } + return sb.toString(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java new file mode 100644 index 0000000..ffd3883 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependency.java @@ -0,0 +1,19 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.Dependency; +import models.terms.EvaluatableTerm; +import models.terms.RDLTerm; + +import java.util.List; + +public class RDLSpecDependency extends Dependency { + + public RDLSpecDependency(RDLSpecDependency dependingTerm, List dependedTerms) { + super(dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + } + + public RDLSpecDependency(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms) { + super((RDLTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + } + +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java new file mode 100644 index 0000000..2c63007 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyFormula.java @@ -0,0 +1,20 @@ +package org.ntlab.rdlcanvas.models; + +import models.formulas.DependencyFormula; + +public class RDLSpecDependencyFormula extends DependencyFormula implements RDLSpecStatement { + + public RDLSpecDependencyFormula(RDLSpecDependency dependency) { + super(dependency); + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java new file mode 100644 index 0000000..b6e5cf0 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecDependencyTerm.java @@ -0,0 +1,61 @@ +package org.ntlab.rdlcanvas.models; + +import exceptions.SyntaxException; +import models.terms.DependencyTerm; +import models.terms.EvaluatableTerm; + +import java.util.List; + +public class RDLSpecDependencyTerm extends DependencyTerm implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valuableType; + + public RDLSpecDependencyTerm(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms, List argumentTerms) { + super((EvaluatableTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList(), argumentTerms.stream().map(item -> (EvaluatableTerm) item).toList()); + this.structuralType = ((Typable) dependingTerm).getStructuralType(); + this.valuableType = ((Typable) dependingTerm).getValueType(); + + for (int i = 0; i < dependedTerms.size(); i ++) { + if (!typeChecker(dependedTerms.get(i), argumentTerms.get(i))) { + throw new SyntaxException("the type is different"); + } + } + } + + private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); + + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { + return true; + } else { + return false; + } + } else { + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); + + if (leftValueType.equals(rightValueType)) { + return true; + } else { + return false; + } + } + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valuableType; + } + + @Override + public boolean isDependencyTerm() { + return true; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java new file mode 100644 index 0000000..a367ac1 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEquationFormula.java @@ -0,0 +1,47 @@ +package org.ntlab.rdlcanvas.models; + +import exceptions.SyntaxException; +import models.formulas.EquationFormula; +import models.terms.EvaluatableTerm; + +public class RDLSpecEquationFormula extends EquationFormula implements RDLSpecStatement { + + public RDLSpecEquationFormula(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { + super((EvaluatableTerm) leftSideHand, (EvaluatableTerm) rightSideHand); + if (!typeChecker(leftSideHand, rightSideHand)) { + throw new SyntaxException("the type is different"); + } + } + + private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); + + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { + return true; + } else { + return false; + } + } else { + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); + + if (leftValueType.equals(rightValueType)) { + return true; + } else { + return false; + } + } + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java new file mode 100644 index 0000000..32108b9 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecEvaluatableTerm.java @@ -0,0 +1,5 @@ +package org.ntlab.rdlcanvas.models; + +public interface RDLSpecEvaluatableTerm { + boolean isDependencyTerm(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java new file mode 100644 index 0000000..43627a2 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecInitialization.java @@ -0,0 +1,47 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecInitialization implements RDLSpecStatement { + RDLSpecEvaluatableTerm leftSideHand; + RDLSpecEvaluatableTerm rightSideHand; + + public RDLSpecInitialization(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { + this.leftSideHand = leftSideHand; + this.rightSideHand = rightSideHand; + } + + public RDLSpecEvaluatableTerm getLeftSideHand() { + return leftSideHand; + } + + public RDLSpecEvaluatableTerm getRightSideHand() { + return rightSideHand; + } + + @Override + public boolean isRDLSpecInitialization() { + return true; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return false; + } + + @Override + public String toString() { + return leftSideHand + " := " + rightSideHand; + } + + @Override + public boolean equals(Object another) { + if (!(another instanceof RDLSpecInitialization anotherInitialization)) { + return false; + } + return leftSideHand.equals(anotherInitialization.getLeftSideHand()) && rightSideHand.equals(anotherInitialization.getRightSideHand()); + } + + @Override + public int hashCode() { + return toString().hashCode(); + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java new file mode 100644 index 0000000..ba6ff86 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecLang.java @@ -0,0 +1,8 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecLang { + public static final ValueType typeString = new ValueType("string"); + public static final ValueType typeInt = new ValueType("int"); + public static final ValueType typeBoolean = new ValueType("boolean"); + public static final ValueType typeDouble = new ValueType("double"); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java new file mode 100644 index 0000000..9401c33 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResource.java @@ -0,0 +1,49 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.Resource; + +public class RDLSpecResource extends Resource implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valueType; + + public RDLSpecResource(String name, int order, StructuralType structuralType, ValueType valueType) { + super(name, order); + if (!(structuralType == StructuralType.structure || structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.map || structuralType == StructuralType.value)) { + throw new IllegalArgumentException(structuralType + " is not expected structural type."); + } + + if (structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.value) { + if (!(valueType.equals(RDLSpecLang.typeInt) || valueType.equals(RDLSpecLang.typeDouble) || valueType.equals(RDLSpecLang.typeString) || valueType.equals(RDLSpecLang.typeBoolean))) { + throw new IllegalArgumentException(structuralType + " is not expected valuable Type."); + } + } else { + if (valueType != null) { + throw new IllegalArgumentException("It does not have a type"); + } + } + + this.structuralType = structuralType; + this.valueType = valueType; + } + + public RDLSpecResource(String name, int order, ValueType valueType) { + super(name, order); + structuralType = StructuralType.primitive; + this.valueType = valueType; + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valueType; + } + + @Override + public boolean isDependencyTerm() { + return false; + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java new file mode 100644 index 0000000..8050ae8 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceConstant.java @@ -0,0 +1,38 @@ +package org.ntlab.rdlcanvas.models; + +import models.terms.ResourceConstant; + +public class RDLSpecResourceConstant extends ResourceConstant implements Typable, RDLSpecEvaluatableTerm { + private StructuralType structuralType; + private ValueType valueType; + + public RDLSpecResourceConstant(String value, ValueType valueType) { + super(value); + this.structuralType = StructuralType.primitive; + this.valueType = valueType; + } + + @Override + public StructuralType getStructuralType() { + return structuralType; + } + + @Override + public ValueType getValueType() { + return valueType; + } + + @Override + public boolean isDependencyTerm() { + return false; + } + + @Override + public String toString() { + if (valueType.getName().equals("string")) { + return "\"" + getName() + "\""; + } else { + return getName(); + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java new file mode 100644 index 0000000..eb4204e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecResourceDeclaration.java @@ -0,0 +1,76 @@ +package org.ntlab.rdlcanvas.models; + +public class RDLSpecResourceDeclaration implements RDLSpecStatement { + private RDLSpecResource resource; + private RDLSpecResource primedResource; + + public RDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + resource = new RDLSpecResource(name, order, structuralType, valueType); + if (structuralType == StructuralType.id) { + primedResource = new RDLSpecResource(name + "'", order, structuralType, valueType); + } else { + primedResource = null; + } + } + + public RDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resource = new RDLSpecResource(name, order, valueType); + primedResource = null; + } + + public RDLSpecResource getResource() { + return resource; + } + + public RDLSpecResource getPrimedResource() { + return primedResource; + } + + @Override + public boolean isRDLSpecInitialization() { + return false; + } + + @Override + public boolean isRDLSpecResourceDeclaration() { + return true; + } + + @Override + public boolean equals(Object another) { + if (!(another instanceof RDLSpecResourceDeclaration rdlSpecResourceDeclaration)) { + return false; + } + + if (rdlSpecResourceDeclaration.getResource().equals(resource) && ((rdlSpecResourceDeclaration.getPrimedResource() == null && primedResource == null) || rdlSpecResourceDeclaration.getPrimedResource().equals(primedResource))) { + return true; + } else { + return false; + } + } + + @Override + public int hashCode() { + return toString().hashCode(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(resource).append("(").append(resource.getOrder()).append("):: "); + + if (resource.getStructuralType() == StructuralType.primitive) { + sb.append(resource.getValueType().getName()); + return sb.toString(); + } + + if (resource.getValueType() == null) { + sb.append(resource.getStructuralType()); + return sb.toString(); + } else { + sb.append(resource.getStructuralType()); + sb.append(", ").append(resource.getValueType().getName()); + return sb.toString(); + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java new file mode 100644 index 0000000..a2bdd1e --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/RDLSpecStatement.java @@ -0,0 +1,6 @@ +package org.ntlab.rdlcanvas.models; + +public interface RDLSpecStatement { + boolean isRDLSpecResourceDeclaration(); + boolean isRDLSpecInitialization(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java b/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java new file mode 100644 index 0000000..d4efbf7 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/StructuralType.java @@ -0,0 +1,26 @@ +package org.ntlab.rdlcanvas.models; + +public enum StructuralType { + id, + value, + structure, + map, + primitive; + + @Override + public String toString() { + switch (this) { + case id: + return "id"; + case value: + return "value"; + case structure: + return "struct"; + case map: + return "map"; + case primitive: + default: + return ""; + } + } +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/Typable.java b/src/main/java/org/ntlab/rdlcanvas/models/Typable.java new file mode 100644 index 0000000..7b2e0ac --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/Typable.java @@ -0,0 +1,7 @@ +package org.ntlab.rdlcanvas.models; + + +public interface Typable { + StructuralType getStructuralType(); + ValueType getValueType(); +} diff --git a/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java b/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java new file mode 100644 index 0000000..3939044 --- /dev/null +++ b/src/main/java/org/ntlab/rdlcanvas/models/ValueType.java @@ -0,0 +1,21 @@ +package org.ntlab.rdlcanvas.models; + +public class ValueType { + private String name; + + public ValueType(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof ValueType)) { + return false; + } + return name.equals(((ValueType) obj).name); + } +}