Small fix for next verifiers

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/domain/vdmn/utils/VDmnFunctions.java

@@ -2,13 +2,16 @@ package de.unikoblenz.fgbks.core.dmn.domain.vdmn.utils;
 
 import de.unikoblenz.fgbks.core.dmn.domain.ids.RuleId;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnColumn;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecisionTable;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDefinition;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputColumn;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputValue;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnOutputColumn;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnRule;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnValue;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VTypeRef;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.Validate;
@@ -43,21 +46,36 @@ public class VDmnFunctions {
         .collect(Collectors.toList());
   }
 
-  public static List<VDmnValue> getColumnValuesInRules(VDmnColumn column, List<RuleId> ruleIds) {
+  public static List<VDmnValue> getColumnValuesInRules(VDmnColumn column, List<VDmnRule> rules) {
+    return getColumnValuesInRuleIds(
+        column, rules.stream().map(VDmnRule::getRuleId).collect(Collectors.toList()));
+  }
+
+  public static List<VDmnValue> getColumnValuesInRuleIds(VDmnColumn column, List<RuleId> ruleIds) {
     return column.getValues().stream()
         .filter(v -> ruleIds.contains(v.getRuleId()))
         .collect(Collectors.toList());
   }
 
   public static List<VDmnInputValue> getColumnValuesInRules(
+      VDmnInputColumn column, List<VDmnRule> rules) {
+    return getColumnValuesInRuleIds(
+        column, rules.stream().map(VDmnRule::getRuleId).collect(Collectors.toList()));
+  }
+
+  public static List<VDmnInputValue> getColumnValuesInRuleIds(
       VDmnInputColumn column, List<RuleId> ruleIds) {
     return column.getInputValues().stream()
         .filter(v -> ruleIds.contains(v.getRuleId()))
         .collect(Collectors.toList());
   }
 
-  public boolean differentConclusions(List<RuleId> ruleIds) {
+  public boolean differentConclusions(List<VDmnRule> ruleIds) {
     // TODO
     return false;
   }
+
+  public List<VDmnRule> getRulesWithEqualOutput(VDmnDecisionTable dmnDecisionTable) {
+    return Collections.emptyList();
+  }
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/IdenticalVerifier.java

@@ -2,7 +2,6 @@ package de.unikoblenz.fgbks.core.dmn.verification.verifier.impl;
 
 import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_EQUAL;
 
-import de.unikoblenz.fgbks.core.dmn.domain.ids.RuleId;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecision;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecisionTable;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputColumn;
@@ -35,30 +34,25 @@ public class IdenticalVerifier extends AbstractVerifier {
 
   private void checkDecisionTable(VDmnDecisionTable dmnDecisionTable) {
     checkForIdenticalRules(
-        dmnDecisionTable,
-        dmnDecisionTable.getInputColumns(),
-        0,
-        new ArrayList<>(
-            dmnDecisionTable.getRules().stream()
-                .map(VDmnRule::getRuleId)
-                .collect(Collectors.toList())));
+        dmnDecisionTable, dmnDecisionTable.getInputColumns(), 0, dmnDecisionTable.getRules());
   }
 
   protected void checkForIdenticalRules(
       VDmnDecisionTable dmnDecisionTable,
       List<VDmnInputColumn> inputs,
       int i,
-      List<RuleId> currentRuleIds) {
+      List<VDmnRule> currentRules) {
     if (i == inputs.size()) {
-      currentRuleIds.forEach(
-          ruleId ->
+      currentRules.forEach(
+          rule ->
               vref.addElement(
-                  VerificationResultEntryElement.create(dmnDecisionTable).withIdentifier(ruleId)));
+                  VerificationResultEntryElement.create(dmnDecisionTable)
+                      .withIdentifier(rule.getRuleId())));
       vref.addToEntry(VerificationClassification.WARNING, "identical");
     } else {
       List<VDmnInputValue> curInVals = new ArrayList<>();
       List<VDmnInputValue> sortInVals =
-          VDmnFunctions.getColumnValuesInRules(inputs.get(i), currentRuleIds);
+          VDmnFunctions.getColumnValuesInRules(inputs.get(i), currentRules);
       sortInVals.sort(Comparator.comparing(VDmnInputValue::getBoundary));
       VDmnInputValue lastVal = null;
       for (VDmnInputValue curVal : sortInVals) {
@@ -72,7 +66,7 @@ public class IdenticalVerifier extends AbstractVerifier {
                   dmnDecisionTable,
                   inputs,
                   i + 1,
-                  curInVals.stream().map(VDmnValue::getRuleId).collect(Collectors.toList()));
+                  curInVals.stream().map(VDmnValue::getDmnRule).collect(Collectors.toList()));
             }
             curInVals.clear();
           }
@@ -85,7 +79,7 @@ public class IdenticalVerifier extends AbstractVerifier {
             dmnDecisionTable,
             inputs,
             i + 1,
-            curInVals.stream().map(VDmnValue::getRuleId).collect(Collectors.toList()));
+            curInVals.stream().map(VDmnValue::getDmnRule).collect(Collectors.toList()));
       }
     }
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/OverlappingVerifier.java

@@ -4,11 +4,11 @@ import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.
 import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_OVERLAPPING;
 import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.SUBSUMES;
 
-import de.unikoblenz.fgbks.core.dmn.domain.ids.RuleId;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecision;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecisionTable;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputColumn;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputValue;
+import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnRule;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnValue;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.utils.VDmnFunctions;
 import de.unikoblenz.fgbks.core.dmn.verification.result.VerificationResultEntry.VerificationClassification;
@@ -39,7 +39,7 @@ public class OverlappingVerifier extends AbstractVerifier {
     checkOverlapping(
         new ArrayList<>(dmnDecisionTable.getInputColumns()),
         0,
-        dmnDecisionTable.getRulesIds(),
+        dmnDecisionTable.getRules(),
         false,
         Collections.emptyList());
   }
@@ -47,9 +47,9 @@ public class OverlappingVerifier extends AbstractVerifier {
   private void checkOverlapping(
       List<VDmnInputColumn> inColumns,
       int i,
-      List<RuleId> currentRuleIds,
+      List<VDmnRule> currentRuleIds,
       boolean hasOverlap,
-      List<RuleId> subsumptionRules) {
+      List<VDmnRule> subsumptionRules) {
     // no more columns to check
     if (i == inColumns.size()) {
       // do nothing, if there was no real overlap found prev..
@@ -57,10 +57,10 @@ public class OverlappingVerifier extends AbstractVerifier {
         // add to rules to result
         // TODO
         currentRuleIds.forEach(
-            ruleId ->
+            rule ->
                 vref.addElement(
                     VerificationResultEntryElement.create(inColumns.get(0).getDmnDecisionTable())
-                        .withIdentifier(ruleId)));
+                        .withIdentifier(rule.getRuleId())));
         vref.addToEntry(VerificationClassification.WARNING, "overlapping");
       }
     } else {
@@ -93,11 +93,11 @@ public class OverlappingVerifier extends AbstractVerifier {
           }
         }
         if (foundNotInContact && currentBoundsCpy.size() > 1) {
-          List<RuleId> newSubsumtionRules = searchSubsubmtionElement(currentBoundsCpy);
+          List<VDmnRule> newSubsumtionRules = searchSubsubmtionElement(currentBoundsCpy);
           checkOverlapping(
               inColumns,
               i + 1,
-              currentBoundsCpy.stream().map(VDmnValue::getRuleId).collect(Collectors.toList()),
+              currentBoundsCpy.stream().map(VDmnValue::getDmnRule).collect(Collectors.toList()),
               hasOverlap
                   || foundPOverlap
                   || (newSubsumtionRules.size() > 0
@@ -107,12 +107,12 @@ public class OverlappingVerifier extends AbstractVerifier {
           foundPOverlap = false;
         }
         if (z == sortedBounds.size() && currentBounds.size() > 1) {
-          List<RuleId> newSubsumtionRules = searchSubsubmtionElement(currentBounds);
+          List<VDmnRule> newSubsumtionRules = searchSubsubmtionElement(currentBounds);
           // check if
           checkOverlapping(
               inColumns,
               i + 1,
-              currentBounds.stream().map(VDmnValue::getRuleId).collect(Collectors.toList()),
+              currentBounds.stream().map(VDmnValue::getDmnRule).collect(Collectors.toList()),
               hasOverlap
                   || foundOverlap
                   || (newSubsumtionRules.size() > 0
@@ -125,10 +125,10 @@ public class OverlappingVerifier extends AbstractVerifier {
     }
   }
 
-  private boolean containsNoDuplicateRows(List<RuleId> ri1, List<RuleId> ri2) {
-    for (RuleId r1 : ri1) {
-      for (RuleId r2 : ri2) {
-        if (r1.equals(r2)) {
+  private boolean containsNoDuplicateRows(List<VDmnRule> ri1, List<VDmnRule> ri2) {
+    for (VDmnRule r1 : ri1) {
+      for (VDmnRule r2 : ri2) {
+        if (r1.getRuleId().equals(r2.getRuleId())) {
           return false;
         }
       }
@@ -136,8 +136,8 @@ public class OverlappingVerifier extends AbstractVerifier {
     return true;
   }
 
-  private List<RuleId> searchSubsubmtionElement(List<VDmnInputValue> inValues) {
-    List<RuleId> subsubmtionRules = new ArrayList<>();
+  private List<VDmnRule> searchSubsubmtionElement(List<VDmnInputValue> inValues) {
+    List<VDmnRule> subsubmtionRules = new ArrayList<>();
     outer:
     for (VDmnInputValue value : inValues) {
       boolean containsSubsumption = false;
@@ -150,7 +150,7 @@ public class OverlappingVerifier extends AbstractVerifier {
         }
       }
       if (containsSubsumption) {
-        subsubmtionRules.add(value.getRuleId());
+        subsubmtionRules.add(value.getDmnRule());
       }
     }
     return subsubmtionRules;

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/core/dmn/verification/verifier/impl/SubsumptionVerifier.java

@@ -3,7 +3,6 @@ package de.unikoblenz.fgbks.core.dmn.verification.verifier.impl;
 import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_EQUAL;
 import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.SUBSUMES;
 
-import de.unikoblenz.fgbks.core.dmn.domain.ids.RuleId;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecision;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnDecisionTable;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VDmnInputColumn;
@@ -38,14 +37,15 @@ public class SubsumptionVerifier extends AbstractVerifier {
     checkSubsumptions(
         new ArrayList<>(dmnDecisionTable.getInputColumns()),
         0,
-        dmnDecisionTable.getRulesIds(),
+        dmnDecisionTable.getRules(),
         false,
         Collections.emptyList());
   }
 
-  private void checkSubsumptions(List<VDmnInputColumn> inColumns,
+  private void checkSubsumptions(
+      List<VDmnInputColumn> inColumns,
       int i,
-      List<RuleId> currentRuleIds,
+      List<VDmnRule> currentRuleIds,
       boolean hasSubsumption,
       List<VDmnRule> currentRootSubsumptionElements) {
     if (i == inColumns.size()) {
@@ -53,10 +53,10 @@ public class SubsumptionVerifier extends AbstractVerifier {
         // add to rules to result
         // TODO
         currentRuleIds.forEach(
-            ruleId ->
+            rule ->
                 vref.addElement(
                     VerificationResultEntryElement.create(inColumns.get(0).getDmnDecisionTable())
-                        .withIdentifier(ruleId)));
+                        .withIdentifier(rule.getRuleId())));
         vref.addToEntry(VerificationClassification.WARNING, "subsumption");
       }
     } else {
@@ -139,10 +139,10 @@ public class SubsumptionVerifier extends AbstractVerifier {
             if (clusters.get(y) != null) {
               List<VDmnInputValue> c2 = clusters.get(y);
               if (x != y
-                  && ((!subsumptionValue.get(x).isEmpty()  && !subsumptionValue.get(y).isEmpty())
-                  || ((subsumptionValue.get(x).isEmpty() && subsumptionValue.get(y).isEmpty())
-                  && c1.containsAll(c2)
-                  && c2.containsAll(c1)))) {
+                  && ((!subsumptionValue.get(x).isEmpty() && !subsumptionValue.get(y).isEmpty())
+                      || ((subsumptionValue.get(x).isEmpty() && subsumptionValue.get(y).isEmpty())
+                          && c1.containsAll(c2)
+                          && c2.containsAll(c1)))) {
                 if (c1.containsAll(c2)) {
                   clusters.set(y, null);
                 }
@@ -158,15 +158,13 @@ public class SubsumptionVerifier extends AbstractVerifier {
           checkSubsumptions(
               inColumns,
               i + 1,
-              vals.stream().map(VDmnInputValue::getRuleId).collect(Collectors.toList()),
+              vals.stream().map(VDmnInputValue::getDmnRule).collect(Collectors.toList()),
               subsumptions.get(x) || hasSubsumption,
-              subsumptionValue.get(x)
-                  .stream().map(VDmnValue::getDmnRule)
+              subsumptionValue.get(x).stream()
+                  .map(VDmnValue::getDmnRule)
                   .collect(Collectors.toList()));
         }
       }
     }
-
   }
-
 }