Second version

.gitignore

@@ -10,3 +10,5 @@ buildNumber.properties
 # https://github.com/takari/maven-wrapper#usage-without-binary-jar
 .mvn/wrapper/maven-wrapper.jar
 .DS_Store
+/logs.log
+/.idea/

pom.xml

@@ -6,21 +6,21 @@
 
     <groupId>at.tugraz.ist.ase</groupId>
     <artifactId>choco-kb</artifactId>
-    <version>1.0.5</version>
+    <version>1.2</version>
     <packaging>jar</packaging>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <maven.compiler.source>16</maven.compiler.source>
-        <maven.compiler.target>16</maven.compiler.target>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
     </properties>
 
     <dependencies>
         <dependency>
-            <groupId>org.choco-solver</groupId>
-            <artifactId>choco-solver</artifactId>
-            <version>4.10.2</version>
+            <groupId>at.tugraz.ist.ase</groupId>
+            <artifactId>fm</artifactId>
+            <version>1.2</version>
         </dependency>
     </dependencies>
 

src/main/java/at/tugraz/ist/ase/common/ConstraintUtils.java

@@ -0,0 +1,49 @@
+/*
+ * ChocoKB: Constraint-based Knowledge Bases for Choco Solver
+ *
+ * Copyright (c) 2021-2022
+ *
+ * @author: Viet-Man Le (vietman.le@ist.tugraz.at)
+ */
+
+package at.tugraz.ist.ase.common;
+
+import at.tugraz.ist.ase.knowledgebases.core.Constraint;
+import lombok.NonNull;
+import lombok.experimental.UtilityClass;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@UtilityClass
+public final class ConstraintUtils {
+
+    public String convertToString(@NonNull Set<Constraint> ac) {
+        return ac.stream().map(Constraint::toString).collect(Collectors.joining("\n"));
+    }
+
+    public String convertToStringWithMessage(@NonNull List<Set<Constraint>> allDiag, @NonNull String mess) {
+        StringBuilder sb = new StringBuilder();
+        int count = 0;
+        for (Set<Constraint> diag : allDiag) {
+            count++;
+
+            sb.append(mess).append(" ").append(count).append(":\n");
+//            System.out.println(mess + " " + count + ":");
+//            sb.append(String.join("\n", diag));
+            sb.append(convertToString(diag)).append("\n");
+//            diag.forEach(System.out::println);
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        return sb.toString();
+    }
+
+    public boolean isMinimal(Set<Constraint> diag, List<Set<Constraint>> allDiag) {
+        return allDiag.stream().noneMatch(diag::containsAll);
+    }
+
+    public boolean containsAll(List<Set<Constraint>> allDiag, Set<Constraint> diag) {
+        return allDiag.stream().anyMatch(adiag -> adiag.containsAll(diag));
+    }
+}

src/main/java/at/tugraz/ist/ase/knowledgebases/core/BoolVariable.java

@@ -0,0 +1,46 @@
+/*
+ * ChocoKB: Constraint-based Knowledge Bases for Choco Solver
+ *
+ * Copyright (c) 2021-2022
+ *
+ * @author: Viet-Man Le (vietman.le@ist.tugraz.at)
+ */
+
+package at.tugraz.ist.ase.knowledgebases.core;
+
+import at.tugraz.ist.ase.common.LoggerUtils;
+import lombok.*;
+import lombok.extern.slf4j.Slf4j;
+import org.chocosolver.solver.variables.BoolVar;
+
+@EqualsAndHashCode(callSuper = true)
+@Getter
+@Slf4j
+public class BoolVariable extends Variable implements Cloneable {
+    private BoolVar chocoVar;
+
+    @Builder
+    public BoolVariable(@NonNull String name, @NonNull Domain domain, @NonNull BoolVar chocoVar) {
+        super(name, domain);
+        this.chocoVar = chocoVar;
+
+        log.trace("{}Created BoolVariable [var={}]", LoggerUtils.tab, this);
+    }
+
+    public String getValue() {
+        return domain.getValue(getChocoValue());
+    }
+
+    public int getChocoValue() {
+        return chocoVar.getValue();
+    }
+
+    @Override
+    public BoolVariable clone() {
+        BoolVariable clone = (BoolVariable) super.clone();
+        clone.chocoVar = chocoVar;
+
+        log.trace("{}Cloned BoolVariable [var={}]", LoggerUtils.tab, clone);
+        return clone;
+    }
+}

src/main/java/at/tugraz/ist/ase/knowledgebases/core/Constraint.java

@@ -0,0 +1,92 @@
+/*
+ * ChocoKB: Constraint-based Knowledge Bases for Choco Solver
+ *
+ * Copyright (c) 2021-2022
+ *
+ * @author: Viet-Man Le (vietman.le@ist.tugraz.at)
+ */
+
+package at.tugraz.ist.ase.knowledgebases.core;
+
+import at.tugraz.ist.ase.common.LoggerUtils;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.extern.slf4j.Slf4j;
+import org.chocosolver.solver.Model;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
+@Getter
+@Slf4j
+public class Constraint {
+    private final String constraint;
+    private final List<org.chocosolver.solver.constraints.Constraint> chocoConstraints;
+    private final List<org.chocosolver.solver.constraints.Constraint> negChocoConstraints;
+
+    public Constraint(@NonNull String constraint) {
+        this.constraint = constraint;
+        chocoConstraints = new LinkedList<>();
+        negChocoConstraints = new LinkedList<>();
+
+        log.trace("{}Created Constraint [cstr={}]", LoggerUtils.tab, constraint);
+    }
+
+    public void addChocoConstraints(Model model, int startIdx, int endIdx, boolean hasNegativeConstraints) {
+        org.chocosolver.solver.constraints.Constraint[] constraints = model.getCstrs();
+
+        if (hasNegativeConstraints) {
+            endIdx = endIdx - 2;
+        } else {
+            endIdx = endIdx - 1;
+        }
+
+        int index = startIdx;
+        while (index <= endIdx) {
+            addChocoConstraint(constraints[index]);
+            if (hasNegativeConstraints) {
+                addNegChocoConstraint(constraints[index]);
+            }
+            index++;
+        }
+
+        addChocoConstraint(constraints[index]);
+        if (hasNegativeConstraints) {
+            addNegChocoConstraint(constraints[index + 1]);
+        }
+    }
+
+    public void addChocoConstraint(@NonNull org.chocosolver.solver.constraints.Constraint constraint) {
+        chocoConstraints.add(constraint);
+
+        log.trace("{}Added a Choco constraint to Constraint [choco_cstr={}, cstr={}]", LoggerUtils.tab, constraint, this);
+    }
+
+    public void addNegChocoConstraint(@NonNull org.chocosolver.solver.constraints.Constraint constraint) {
+        negChocoConstraints.add(constraint);
+
+        log.trace("{}Added a negative Choco constraint to Constraint [choco_cstr={}, cstr={}]", LoggerUtils.tab, constraint, this);
+    }
+
+    public boolean contains(@NonNull org.chocosolver.solver.constraints.Constraint constraint) {
+        return chocoConstraints.contains(constraint);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Constraint that)) return false;
+        return Objects.equals(constraint, that.constraint);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(constraint);
+    }
+
+    @Override
+    public String toString() {
+        return constraint;
+    }
+}