Sorted columns

dmn-verifier-app/src/main/java/de/unikoblenz/fgbks/dmn/core/verifier/IdenticalRules.java

@@ -8,24 +8,17 @@ import de.unikoblenz.fgbks.dmn.core.verifier.helper.Value;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
-import java.util.Set;
-import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import org.camunda.bpm.dmn.engine.DmnDecision;
 
 public class IdenticalRules extends AbstractVerifier {
 
-  private static final Logger LOGGER = Logger.getLogger(IdenticalRules.class.getSimpleName());
-  private Set<Set<String>> identicaldecicionTables;
-
   public IdenticalRules() {
     super(VerifierType.Identical);
   }
 
   @Override
-  protected void beforeVerifyDecision() {
-    identicaldecicionTables = ruleMap.getIncludingInputDefinitions();
-  }
+  protected void beforeVerifyDecision() {}
 
   @Override
   protected void verifyDecision(DmnDecision d) {

dmn-verifier-app/src/main/java/de/unikoblenz/fgbks/dmn/core/verifier/MissingRules.java

@@ -67,11 +67,12 @@ public class MissingRules extends AbstractVerifier {
           missingIntervals.stream().filter(Objects::nonNull).collect(Collectors.toList())) {
         StringBuilder sb = new StringBuilder("In table ");
         sb.append(d.getName()); // TODO: add real name
-        sb.append(" the following rule is not defined: ");
+        sb.append(" the following rule is not defined: (");
         sb.append(
             Arrays.stream(missingInt)
                 .map(Value::getOrgExpression)
-                .collect(Collectors.joining(" / ")));
+                .collect(Collectors.joining("), (")));
+        sb.append(")");
         addVerification(
             VerificationResult.getBuilder()
                 .addRules(

dmn-verifier-app/src/main/java/de/unikoblenz/fgbks/dmn/core/verifier/helper/RuleMap.java

@@ -25,13 +25,17 @@ public class RuleMap {
   private static final Logger LOGGER = Logger.getLogger(RuleMap.class.getSimpleName());
   private List<DmnDecision> dmnDecisions;
   private Map<InputType, List<Value>> inputs;
+  private List<InputType> inputColumns;
   private Map<OutputType, List<Value>> outputs;
+  private List<OutputType> outputColumns;
   private Set<String> dmnDecisionsKeys;
 
   private RuleMap(List<DmnDecision> dmnDecisions) {
     this.dmnDecisions = new ArrayList<>(dmnDecisions);
     this.inputs = new HashMap<>();
+    this.inputColumns = new ArrayList<>();
     this.outputs = new HashMap<>();
+    this.outputColumns = new ArrayList<>();
     this.dmnDecisionsKeys = new HashSet<>();
   }
 
@@ -51,6 +55,7 @@ public class RuleMap {
         int i = 0;
         for (DmnDecisionTableInputImpl tableInput : table.getInputs()) {
           InputType it = new InputType(d, tableInput);
+          ruleMap.inputColumns.add(it);
           ruleMap.inputs.put(it, new ArrayList<>());
           List<Value> inList = ruleMap.inputs.get(it);
           int r = 0;
@@ -64,6 +69,7 @@ public class RuleMap {
         i = 0;
         for (DmnDecisionTableOutputImpl tableOutput : table.getOutputs()) {
           OutputType ot = new OutputType(d, tableOutput);
+          ruleMap.outputColumns.add(ot);
           ruleMap.outputs.put(ot, new ArrayList<>());
           List<Value> outList = ruleMap.outputs.get(ot);
           int r = 0;
@@ -197,8 +203,7 @@ public class RuleMap {
    * @return a list of Input types
    */
   public List<Type> getAllInputTypesFromDecisionKey(String decisionKey) {
-    return inputs
-        .keySet()
+    return inputColumns
         .stream()
         .filter(i -> i.getDecisionKey().equals(Objects.requireNonNull(decisionKey)))
         .collect(Collectors.toList());
@@ -211,8 +216,7 @@ public class RuleMap {
    * @return a list of Output types
    */
   public List<Type> getAllOutputTypesFromDecisionKey(String decisionKey) {
-    return outputs
-        .keySet()
+    return outputColumns
         .stream()
         .filter(i -> i.getDecisionKey().equals(decisionKey))
         .collect(Collectors.toList());